Linked-List-Int.c

#include "Linked-List-Int.h"
#include <stdlib.h>
#include <stdio.h>


void listIntPrint(ListNodeInt* list)
{
    ListNodeInt* currentNode;

    for(currentNode = list; currentNode != NULL; currentNode = currentNode->next)
    {
        printf("%d ", currentNode->value);
    }

    printf("\n");
}

ListNodeInt* listIntAdd(ListNodeInt* list, int value)
{
    ListNodeInt *newNode, *lastNode;

    newNode = (ListNodeInt*)malloc(sizeof(ListNodeInt));
    newNode->value = value;
    newNode->next = NULL;

    if(list == NULL)
        list = newNode;
    else
    {
        lastNode = getLastIntNode(list);
        lastNode->next = newNode;
    }

    return list;
}

ListNodeInt* listIntAddSorted(ListNodeInt* list, int value)
{
    ListNodeInt *newNode, *currentNode, *nextNode;

    newNode = (ListNodeInt*)malloc(sizeof(ListNodeInt));
    newNode->value = value;
    newNode->next = NULL;

    if(list == NULL)
        list = newNode;
    else
    {
        // If value is smaller than smallest value of the list (first position)
        if(value < list->value)
        {
            newNode->next = list;
            list = newNode;
        }
        else
        {
            // Get the node with the largest value smaller than the value to be added
            currentNode = list;
            while(currentNode->next != NULL && currentNode->next->value < value)
                currentNode = currentNode->next;

            // If currentNode is last element
            if(currentNode->next == NULL)
                currentNode->next = newNode;
            else
            {
                nextNode = currentNode->next;
                currentNode->next = newNode;
                newNode->next = nextNode;
            }
        }
    }

    return list;
}

ListNodeInt* listIntUpdate(ListNodeInt* list, int index, int oldValue, int newValue)
{
    ListNodeInt* node;
    int currentIndex;

    currentIndex = 0;
    node = list;
    while(node != NULL)
    {
        if(node->value == oldValue)
            break;
        node = node->next;
        currentIndex += 1;
    }

    // If (safety) conditions are met
    if(node->value == oldValue && currentIndex == index)
    {
        node->value = newValue;
        return list;
    }

    return NULL;
}

ListNodeInt* listIntRemove(ListNodeInt* list, int value)
{
    ListNodeInt *node, *auxNode;

    node = list;

    // Case 1: value is the first node
    if(node->value == value)
    {
        list = node->next;
        free(node);
        return list;
    }
    else
    {
        // Case 2: value is somewhere else in list
        while(node->next != NULL)
        {
            if(node->next->value == value)
            {
                auxNode = node->next;
                node->next = auxNode->next;
                free(auxNode);
                break;
            }
            node = node->next;
        }
    }

    return list;
}

ListNodeInt* listIntFind(ListNodeInt* list, int value)
{
    ListNodeInt *node;

    node = list;
    while(node != NULL)
    {
        if(node->value == value)
            return node;
        node = node->next;
    }

    return NULL;
}

ListNodeInt* getLastIntNode(ListNodeInt* list)
{
    ListNodeInt *node;

    if(list == NULL) return NULL;
    
    node = list;
    while(node->next != NULL)
        node = node->next;

    return node;
}

ListNodeInt* getIndexIntNode(ListNodeInt* list, int index)
{
    ListNodeInt *node;
    int count;

    node = list;
    count = 0;
    while(node != NULL)
    {
        if(count == index)
            return node;
        count++;
        node = node->next;
    }

    return NULL;
}

int getSortedIndexOfValue(ListNodeInt* list, int value)
{
    ListNodeInt* node;
    int count;

    node = list;
    count = 0;
    while(node != NULL && (node->value < value))
    {
        count++;
        node = node->next;
    }

    return count;
}