C 链表删除节点

所以我试图实现一个函数，从链表中删除节点

以下是我的主要观点：

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;
}

这是我的输出：

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

输出应该是（因为在

main（）

中，我删除了

jank

，并将链表的大小减小了一个）：

以下是我的全部源代码：

#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;
    }
}

#包括
#包括
/*节点结构*/
类型定义结构节点{
字符*事物；
int pos；/*节点索引*/
结构节点*下一个；/*指向下一个节点的指针*/
}节点；
/*生成单个节点*/
节点*generateNode（）；
/*生成链接节点并返回第一个节点*/
节点*生成节点（int num）；
/*获取某个索引处的节点*/
NODE*getNode（NODE*start，int索引）；
/*返回节点列表的长度*/
大小\u t getNodeListLength（节点*开始）；
/*删除某个索引处的节点*/
节点*删除节点（节点*开始，int索引）；
内部主（空）
{
节点*第一个=生成节点（5）；
NODE*jank=getNode（第一，2）；
删除节点（第一，2）；
printf（“节点列表的长度：%d\n”，getNodeListLength（第一个））；
printf（“第一个节点：%d\n”，第一个->位置）；
printf（“其他节点：%d\n”，jank->pos）；
返回0；
}
节点*generateNode（）
{
返回（节点*）malloc（sizeof（节点））；
}
节点*生成节点（int num）
{
NODE*one=generateNode（）；
节点*cpy=1；
int i；
对于（i=0；inext=next；
cpy->pos=i；
cpy=下一个；
}
cpy->pos=i；
cpy->next=NULL；
返回一个；
}
NODE*getNode（NODE*start，int索引）
{
int i；
对于（i=0；i下一步；
}
返回启动；
}
大小\u t getNodeListLength（节点*开始）
{
尺寸i；
while（开始->下一步！=NULL）
{
开始=开始->下一步；
i++；
}
返回i-1；
}
节点*删除节点（节点*开始，int索引）
{
如果（索引>0）
{
NODE*f=getNode（开始，索引-1）；
NODE*l=getNode（开始，索引+1）；
NODE*d=getNode（开始，索引）；
f->next=l；
免费（d）；
返回启动；
}
如果（索引==0）
{
节点*up=开始->下一步；
自由（启动）；
返回；
}
如果（索引+1==getNodeListLength（开始））
{
NODE*r=getNode（开始，索引）；
NODE*c=getNode（开始，索引-1）；
c->next=NULL；
自由（r）；
返回启动；
}
}

---

哪里出错了？

我注意到

getNodeListLength

中的

size\t I

未初始化为任何值-这可能是意外大小报告的来源

---

另外，您从列表中删除了

jank

，但是

jank

指针仍然指向节点（即使它是

free

'd）-这意味着在此之后使用

jank

访问不再属于您的内存

我的错误出现在这个函数中：

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

应该是：

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

试一试

---

有时，指定您最不熟悉的代码部分做了它应该做的事情，并密切关注它，这可能会有所帮助。

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

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