Linked List Delete Node

Question

So I'm trying to implement a function that deletes nodes from a linked list.

Here's my main:

int main(void)
{
    NODE* first = generateNodes(5);
    NODE* jank = getNode(first, 2);
    deleteNode(first,2);
    printf("Length of Node List: %d\n",getNodeListLength(first));
    printf("First Node: %d\n",first -> pos); 
    printf("Jank Node: %d\n",jank -> pos); 
    return 0;
}

This is my output:

Length of Node List: 2
First Node: 0
Jank Node: 2

The output should be (because in main() I removed jank, and decreased the size of the linked list by one):

Length of Node List: 4
First Node: 0
Jank Node: NULL

Here's my entire source code:

#include <stdio.h>
#include <stdlib.h>

/* NODE STRUCTURE */

typedef struct node{

    char* thing;

    int pos; /* Index of node */
    struct node* next; /* Pointer to next node */

} NODE;

/* Generates a single node */ 
NODE* generateNode();

/* Generates linked nodes and returns the first node */
NODE* generateNodes(int num);

/* Gets a node at a certain index */
NODE* getNode(NODE* start, int index);

/* Returns the length of a list of nodes */
size_t getNodeListLength(NODE* start);

/* Removes a node at a certain index */
NODE* deleteNode(NODE* start, int index);

int main(void)
{
    NODE* first = generateNodes(5);
    NODE* jank = getNode(first, 2);
    deleteNode(first,2);
    printf("Length of Node List: %d\n",getNodeListLength(first));
    printf("First Node: %d\n",first -> pos); 
    printf("Other Node: %d\n",jank -> pos); 
    return 0;
}

NODE* generateNode()
{
    return (NODE*) malloc(sizeof(NODE));
}

NODE* generateNodes(int num)
{
    NODE* one = generateNode();
    NODE* cpy = one;

    int i;

    for(i = 0; i < num - 1; i++)
    {

        NODE* next = generateNode();
        cpy -> next = next;
        cpy -> pos = i;
        cpy = next;

    }

    cpy -> pos = i;
    cpy -> next = NULL;

    return one;
}

NODE* getNode(NODE* start, int index)
{
    int i;
    for(i = 0; i < index; i++)
    {
        start = start -> next;
    }
    return start;
}

size_t getNodeListLength(NODE* start)
{
    size_t i;
    while(start -> next != NULL)
    {
        start = start -> next;
        i++;
    }
    return i - 1;
}

NODE* deleteNode(NODE* start, int index)
{
    if(index > 0)
    {
        NODE* f = getNode(start,index - 1);
        NODE* l = getNode(start,index + 1);
        NODE* d = getNode(start,index);
        f -> next = l;
        free(d);
        return start;
    }
    if(index == 0)
    {
        NODE* up = start -> next;
        free(start);
        return up;
    }
    if(index + 1 == getNodeListLength(start))
    {
        NODE* r = getNode(start,index);
        NODE* c = getNode(start,index - 1);
        c -> next = NULL;
        free(r);
        return start;
    }
}

Where did I go wrong?

Answer 1

try

//modify this method
size_t getNodeListLength(NODE* start)
{
    size_t i = 0;
    while(start != NULL)
    {
        start = start -> next;
        i++;
    }
    return i;
}

Answer 2

I notice your size_t i in getNodeListLength is not initialized to any value - this could be the source of the unexpected size reporting.

Also, you remove jank from the list, but your jank pointer is still pointing to the node (even though it has been free'd) - this means using jank after that is accessing memory that is no longer yours!

Answer 3

Turns out my error was in this function:

size_t getNodeListLength(NODE* start)
{
    size_t i;
    while(start -> next != NULL)
    {
        start = start -> next;
        i++;
    }
    return i - 1;
}

should be:

size_t getNodeListLength(NODE* start)
{
    size_t i = 1;
    while(start -> next != NULL)
    {
        start = start -> next;
        i++;
    }
    return i;
}