C语言链表写入冲突

Emily-CS

调试的显示是：
心好累啊.exe 中的 0x0115173b 处有未经处理的异常: 0xC0000005: 读取位置 0xfeeefef2 时发生访问冲突

指向出问题的地方：
int length_list (NODE *  pHead)
{
        int len = 0;
        NODE *  p = pHead->pNext;
        while (p != NULL)
        {
                len++;
                printf("%d",len);
                p = p->pNext;  //这里显示有问题

        }
        printf("%d",len);
        return len;
}

但是为什么会这样啊？

下附整个程序：（用动态链表实现报数报到3踢出局）
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

//函数声明

struct NODE1
{
        int data;
        struct NODE1 * pNext;
};
typedef struct NODE1 NODE;
//typedef struct NODE1 * PNODE;


NODE * creat_list();
int length_list (NODE *  pHead);
void delete_list(NODE *  pHead, NODE *  p);


int main()
{
        NODE *  pHead = creat_list();
        int count = 0;
        NODE *  p = pHead;
        while (length_list(pHead)>1)
        {
                p = p->pNext;
                ++ count;
                if (count == 3 && p != NULL)
                {
                        delete_list (pHead, p);
                        count = 0;
                }
                if (p == NULL)
                {
                        p = pHead;
                }
        }
        printf ("剩余的人的编号是：%d", pHead->pNext->data);
        while (1);
        return 0 ;
       
}

NODE *  creat_list()
{
        NODE *  pHead = (NODE * )malloc(sizeof(NODE));
        int len, data, i;
        NODE * pTail;
        printf("一共多少人玩(请输入人数)：\n");
        scanf_s ("%d", &len);
        if (pHead == NULL)
        {
                printf ("分配内存失败，程序结束！");
                exit(-1);
        }
        pHead->pNext = NULL;
        pTail = pHead;

        for (i=0; i<len; i++)
        {
                NODE *  pNew = (NODE * )malloc(sizeof(NODE));
                if (pNew == NULL)
                {
                  printf ("分配内存失败，程序结束！");
                  exit(-1);
                }
                pNew->pNext = NULL;
                pNew->data = i+1;
                printf("%d",pNew->data);
                pTail->pNext = pNew;
                pTail = pNew;
        }
        printf("\n%d",pHead->pNext->data);
        return pHead;
}

int length_list (NODE *  pHead)
{
        int len = 0;
        NODE *  p = pHead->pNext;
        while (p != NULL)
        {
                len++;
                printf("%d",len);
                p = p->pNext;

        }
        printf("%d",len);
        return len;
}

void delete_list(NODE *  pHead, NODE *  p)
{
        //if (pHead->pNext == NULL)
        //        return false;
        NODE *  pTag = pHead->pNext; NODE *  pFore = pHead;
        while (pTag != p)
        {
                pFore = pTag;
                pTag = pTag->pNext;
        }
        if (p->pNext != NULL)
        {
                pTag->pNext = p->pNext;
        }
        else pTag->pNext = NULL;
        free (p);
        p = NULL;
        //return true;
}

ryxcaixia

p = p->pNext 出错 肯定是因为p->pNext是一个无法访问的地址
动态调试看看 单步到崩溃的时候 看看此时p->pNext的值是什么

shuofxz

1. NODE *  p = pHead->pNext;

复制代码

这个你只是声明了一个NODE*类型的指针，但是没有在内存中给p开辟空间呀
改成

1. NODE *  p = (NODE*)malloc(sizeof(NODE）)
   
2. p = pHead->pNext;

复制代码

再试试

immortalfaith

地址错误

mingcxx

感觉你的代码思路有点乱，
创建节点时从第2个节点开始录入数据，整个程序运行中头结点数据一直是不定内存，浪费内存。
删除节点时却只释放了节点所占用的内存（而没有把待删除节点的前一个节点中指向该节点的Next指针更新NULL或指向目标节点的下一节点），那你的链表中依然链接了这个节点，只不过释放内存之后，这个节点的内存不可读。p = p->pNext;自然要出错。
以及没有释放链表占用的内存。
下面是仅仅无bug的修改代码，输出的数据意义不清晰（尤其第3行），依赖具体功能和代码思路需要进一步修改：

1. #include <stdio.h>
   
2. #include <malloc.h>
   
3. #include <stdlib.h>
   
4. 
   
5. //函数声明
   
6. 
   
7. struct NODE1
   
8. {
   
9.         int data;
   
10.         struct NODE1 * pNext;
    
11. };
    
12. typedef struct NODE1 NODE;
    
13. //typedef struct NODE1 * PNODE;
    
14. 
    
15. 
    
16. NODE * creat_list();
    
17. int length_list(NODE *  pHead);
    
18. void delete_list(NODE *  pHead, NODE **  p);
    
19. 
    
20. 
    
21. int main()
    
22. {
    
23.         NODE *  pHead = creat_list();
    
24.         int count = 0;
    
25.         NODE *  p = pHead;
    
26.         while (length_list(pHead)>1)
    
27.         {
    
28.                 p = p->pNext;
    
29.                 ++count;
    
30.                 if (count == 3 && p != NULL)
    
31.                 {
    
32.                         delete_list(pHead, &p);
    
33.                         count = 0;
    
34.                 }
    
35.                 if (p == NULL)
    
36.                 {
    
37.                         p = pHead;
    
38.                 }
    
39.                 if (count < 3)
    
40.                         break;
    
41.         }
    
42.         printf("剩余的人的编号是：%d", pHead->pNext->data);
    
43.         while (1);
    
44.         return 0;
    
45. 
    
46. }
    
47. 
    
48. NODE *  creat_list()
    
49. {
    
50.         NODE *  pHead = (NODE *)malloc(sizeof(NODE));
    
51.         int len, data, i;
    
52.         NODE * pTail;
    
53.         printf("一共多少人玩(请输入人数)：\n");
    
54.         scanf_s("%d", &len);
    
55.         if (pHead == NULL)
    
56.         {
    
57.                 printf("分配内存失败，程序结束！");
    
58.                 exit(-1);
    
59.         }
    
60.         pHead->pNext = NULL;
    
61.         pTail = pHead;
    
62. 
    
63.         for (i = 0; i<len; i++)
    
64.         {
    
65.                 NODE *  pNew = (NODE *)malloc(sizeof(NODE));
    
66.                 if (pNew == NULL)
    
67.                 {
    
68.                         printf("分配内存失败，程序结束！");
    
69.                         exit(-1);
    
70.                 }
    
71.                 pNew->pNext = NULL;
    
72.                 pNew->data = i + 1;
    
73.                 printf("%d", pNew->data);
    
74.                 pTail->pNext = pNew;
    
75.                 pTail = pNew;
    
76.         }
    
77.         printf("\n%d", pHead->pNext->data);
    
78.         return pHead;
    
79. }
    
80. 
    
81. int length_list(NODE *  pHead)
    
82. {
    
83.         int len = 0;
    
84.         NODE *  p = pHead->pNext;
    
85.         while (p != NULL)
    
86.         {
    
87.                 len++;
    
88.                 printf("%d", len);
    
89.                 p = p->pNext;
    
90.         }
    
91.         printf("%d", len);
    
92.         return len;
    
93. }
    
94. 
    
95. void delete_list(NODE *  pHead, NODE **  p)
    
96. {
    
97.         //if (pHead->pNext == NULL)
    
98.         //        return false;
    
99.         NODE *  pTag = pHead; NODE *  pFore = pHead;
    
100.         while (pTag->pNext != *p)
     
101.         {
     
102.                 pFore = pTag;
     
103.                 pTag = pTag->pNext;
     
104.         }
     
105.         if ((*p)->pNext != NULL)
     
106.         {
     
107.                 pTag->pNext= (*p)->pNext;
     
108.         }
     
109.         else
     
110.                 pTag->pNext = NULL;
     
111.         free((*p));
     
112.         *p = NULL;
     
113.         //return true;
     
114. }

复制代码

SingleLove

问题就在你这个函数void delete_list(NODE *  pHead, NODE *  p)释放掉被选中的节点后；
main函数里的辅助指针找不到这个已经被释放掉的节点的地址了；所以就报错了
可以在void delete_list(NODE *  pHead, NODE *  p) 这个函数返回下一个节点的地址;
再用main函数里的辅助指针接一下：p = delete(pHead, p);

下面是我自己写的代码

1. 
   
2. #define _CRT_SECURE_NO_WARNINGS//我是在vs2013做的所以加了这句宏定义 防止 scanf 带来的error
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>//malloc() 等
   
6. #include <Windows.h>//Sleep()
   
7. 
   
8. 
   
9. //定义节点
   
10. typedef struct Node
    
11. {        //数据域
    
12.         int data;
    
13.         //指针域
    
14.         struct Node *next;
    
15. 
    
16. }Node;
    
17. 
    
18. //创建链表
    
19. Node *creatList()
    
20. {
    
21.         printf("请问有多少人玩游戏:");
    
22.         int data;
    
23.         scanf("%d", &data);
    
24. 
    
25.         if (data <= 0)//判断输入的数字是否合法
    
26.         {
    
27.                 printf("请输入大于0的玩家个数\n");
    
28.                 return NULL;
    
29.         }
    
30. 
    
31.         //创建头节点
    
32.         Node * head = (Node *)malloc(sizeof(Node));
    
33.         if (head == NULL)//判断是否成功分配内存
    
34.         {
    
35.                 return NULL;
    
36.         }
    
37.         head->next = NULL;//头结点的指针域指向空
    
38. 
    
39.         Node *cur = NULL;//保存尾结点
    
40.         Node *pNew = NULL;//创建新节点
    
41. 
    
42.         int i = 0;//用于给节点赋值
    
43.         cur = head;//在没创建数据节点前头结点就是尾结点
    
44.         while (cur != NULL)
    
45.         {
    
46.                 i++;
    
47.                 if (cur->data == data)//当节点的值为data时跳出循环
    
48.                 {
    
49.                         break;
    
50.                 }
    
51. 
    
52.                 pNew = (Node *)malloc(sizeof(Node));//创建新节点
    
53.                 pNew->data = i;//给新节点赋值
    
54.                 cur->next = pNew;//使当前节点的next指向新节点
    
55.                 cur = pNew;//保存尾结点
    
56.                 pNew->next = NULL;//尾结点的next指向NULL
    
57.         }
    
58. 
    
59.         return head;//把头节点的地址返回
    
60. }
    
61. 
    
62. //释放被选中的节点
    
63. Node *DelList(Node *head, Node *delNode)
    
64. {
    
65.         if (head == NULL)
    
66.         {
    
67.                 return NULL;
    
68.         }
    
69.         //定义两个变量来查找这个节点和它上一个节点所在位置
    
70. 
    
71.         Node *pre = head;//靠前的
    
72.         Node *cur = head->next;
    
73.         while (cur != NULL)
    
74.         {
    
75.                 if (cur->data == delNode->data)//找到要释放的节点
    
76.                 {
    
77.                         break;
    
78.                 }
    
79.                 pre = pre->next;
    
80.                 cur = cur->next;
    
81.         }
    
82.         //跳出循环时 cur指向delNode这个节点, pre指向delNode的上一个节点
    
83. 
    
84.         pre->next = cur->next;
    
85.         free(cur);
    
86.         cur = pre->next;
    
87.         return cur;//这个很重要;楼主的段错误就是因为没有把这个地址返回造成的;
    
88.         //当你把节点释放之后main函数里的辅助指针( tmp )再也找不到这个节点的地址,
    
89.         //所以就报错了
    
90.         //我返回的是被释放节点的下一个节点的地址
    
91. 
    
92. }
    
93. 
    
94. //获取剩余有效节点的个数(即剩余玩家的个数)
    
95. int listLength(Node *head)
    
96. {
    
97.         if (head == NULL)//判断传入的地址是否有效
    
98.         {
    
99.                 return -1;
    
100.         }
     
101. 
     
102.         int i = 0;//用于计算剩余玩家的个数
     
103.         Node *tmp = head->next;//指向首节点
     
104. 
     
105.         printf("尚未退出游戏的玩家编号分别是：\n");
     
106.         while (tmp != NULL)
     
107.         {
     
108.                
     
109.                 i++;
     
110.                 printf("%d,", tmp->data);//打印剩余玩家的编号
     
111.                
     
112.                 tmp = tmp->next;//跳向下一个数据节点
     
113.         }
     
114.         printf("\n");
     
115. 
     
116.         return i;//返回剩余玩家的个数
     
117. }
     
118. 
     
119. 
     
120. int main()
     
121. {
     
122.         while (1)//循环输入
     
123.         {
     
124.                 Node *head = NULL;
     
125.                 head = creatList();//接返回的地址
     
126.                 if (head == NULL)//创建链表失败
     
127.                 {
     
128.                         return -1;
     
129.                 }
     
130. 
     
131.                 int count = 0;//用于数数;数到3则踢出一个玩家
     
132.                 Node *tmp = head->next;
     
133. 
     
134.                 int i = listLength(head);//有多少个玩家
     
135.                 while (i > 1)
     
136.                 {
     
137. 
     
138.                         if (tmp == NULL)
     
139.                         {
     
140.                                 tmp = head->next;
     
141. 
     
142.                         }
     
143.                         count++;
     
144.                         if (count == 3 && tmp != NULL)
     
145.                         {
     
146.                                 printf("被踢出局的玩家是 %d 号玩家\n", tmp->data);
     
147.                                 tmp = DelList(head, tmp);
     
148.                                 i = listLength(head);
     
149.                                 count = 0;
     
150.                                 continue;
     
151.                         }
     
152.                         tmp = tmp->next;
     
153. 
     
154. 
     
155.                 }
     
156.                 //最后跳出循环肯定只剩下一个玩家没有被踢出游戏的
     
157.                 tmp = head->next;//跳出循环时很可能tmp的值是NULL；
     
158.                 //例如 4 的时候
     
159.                 //那样就会造成段错误；所以需要重新指定下
     
160.                 printf("游戏结束尚未退出游戏的玩家的编号%d\n", tmp->data);
     
161. 
     
162.                 Sleep(3000);//让程序睡眠3秒;linux系统则是 3
     
163. 
     
164.                 system("cls");//清屏
     
165.         }
     
166.        
     
167.         printf("\n");
     
168.         system("pause");
     
169. 
     
170.        
     
171.         return 0;
     
172. }
     

复制代码

aclii

感觉完全看不懂你到底想要实现什么功能