设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › C\C++交流 › 求大神帮忙看看segmentation问题出在哪里
返回列表 发新帖
查看: 1198|回复: 7

[已解决]求大神帮忙看看segmentation问题出在哪里

[复制链接]
Shaky_00
发表于 2020-3-3 22:52:59 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
本帖最后由 Shaky_00 于 2020-3-3 23:16 编辑

一个关于将两个链表连接起来的问题，数据结构入门级程序，在DevCpp上运行出来显示segmentation fault，帮忙看看该怎么修改一下，谢谢！！！

源代码如下：

//将两个链表连接起来
#include<stdio.h>
#include<malloc.h>
#define LEN sizeof(List)

typedef struct node{
        int data;
        struct node * next;
}List;

int main()
{
        // 首先得到m和n的值
        int m, n;
        int count1, count2;
        printf("请输入两个链表的长度m与n：");
        scanf("%d %d", &m, &n);
        List * L1;
        List * L2;//两串需要串联的列表
        L1 = NULL;
        L2 = NULL;//指针初始化
        List *ha, *hb, *hc;//分别指向三个的head
        ha = (List*)malloc(LEN);
        hb = (List*)malloc(LEN);
        hc = (List*)malloc(LEN);//给指针分配内存

        ha = L1;
        hb = L2;
        hc = L1;//指针的初始化

        while(count1 < m)//当读数小于m值时，继续读数进L1表
        {
                scanf("%d", &ha->data);
                ha = ha->next;
                count1++;
        }
        hb = ha;
        free(ha);
        while(count2 < n)
        {
                scanf("%d", &hb->data);
                hb = hb->next;
                count2++;
        }
        hb = NULL;

        while(L1 != NULL)
        {
                do{
                        printf("%d->", hc->data);
                        hc = hc->next;
                }while(hc != NULL);
        }

        return 0;
}
最佳答案
月排行榜 / 总排行榜
major_lyu
2020-3-3 23:30:59
问题太多了，实在是改不过来！！！！！

问题帮你注释了，真的是没法改。帮你修改的时间就可以重新写一个了
  1. //将两个链表连接起来
  2. #include <stdio.h>
  3. #include <malloc.h>

  5. #define LEN sizeof(List) //这个定义是一个List node 的大小，并不是List长度

  7. typedef struct node
  8. {
  9.     int data;
  10.     struct node *next;
  11. } List;

  13. int main()
  14. {
  15.     // 首先得到m和n的值
  16.     int m, n;
  17.     int count1, count2;
  18.     printf("请输入两个链表的长度m与n：");
  19.     scanf("%d %d", &m, &n);
  20.     List *L1;
  21.     List *L2;
  22.     L1 = NULL;
  23.     L2 = NULL;
  24.     List *ha, *hb, *hc;
  25.     //ha = (List*)malloc(LEN); //这样分配的空间只能存储一个List node. 下同
  26.     //hb = (List*)malloc(LEN);
  27.     //hc = (List*)malloc(LEN);

  29.     ha = (List *)malloc(m * LEN); //这样分配的才是m个结点的List,下同
  30.     hb = (List *)malloc(n * LEN);
  31.     hc = (List *)malloc((m + n) * LEN);

  33.     //ha = L1; //这三步执行完 ha = NULL, ha = NULL, hc = NULL,
  34.     //所以后面对ha,hb,hc的操作都是对NULL指针所指空间的操作，当然segmentation fault
  35.     //hb = L2;
  36.     //hc = L1;
  37.     L1 = ha;
  38.     L2 = hb;
  39.     hc = L1; // hc现在和L1指向同一个空间，上面为hc分配的空间就此放弃，永远也访问不到了！！！！！！

  41.     count1 = 0;
  42.     while (count1 < m) // count1没有赋初值，虽然大多数情况下默认值是0，但这样很不安全
  43.     {
  44.         scanf("%d", &ha->data);
  45.         ha = ha->next;  //上面只是分配了存储List的空间，但是并没有建立处理链表结构，这是，ha->next的值并真的就是用空间。你这样做ha第二个往后的结点就访问不到了d//
  46.         count1++;
  47.     }
  48.     hb = ha; //hb和ha指向同一空间，
  49.     free(ha); // free(ha)，相当于把hb,和 ha指向的那个结点空间释放了，那么hb,和ha指针都悬空了。你这样做ha第二个往后的结点就访问不到了
  50.               //执行完这一步， hb指向的空间已经被free了， 那么下面对hb的访问也就segmentation fault了
  51.               // 就算上面的都没问题了，当跳出上面的while时，ha指向的是L1的最后一个结点之后的结点， 下面的while访问hb时访问的就是个没有分配的空间
  52. //
  53.     while (count2 < n)
  54.     {
  55.         scanf("%d", &hb->data);
  56.         hb = hb->next;
  57.         count2++;
  58.     }
  59.     hb = NULL; //这种赋值没有必要的，并不能节省空间
  60.     // 到目前为止，没看到链表拼接的任何操作
  61.     while (L1 != NULL) //这个循环永远不会结束。L1的值在整个循环中不会改变，也永远不可能等于NULL
  62.     {
  63.         do
  64.         {
  65.             printf("%d->",hc->data);
  66.             hc = hc->next;
  67.         } while (hc != NULL);
  68.         // 这个内层循环跳出后会在外层while中一直空转。你这内层循环和外层循环有什么关系吗。
  69.     }

  71.     return 0;
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

_谪仙
发表于 2020-3-3 23:27:42 | 显示全部楼层
本帖最后由 _谪仙 于 2020-3-3 23:32 编辑

链表初始化并不是一个NULL，而是一个空链表，还有你创建的节点空间都被覆盖掉了
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

major_lyu
发表于 2020-3-3 23:30:59 | 显示全部楼层    本楼为最佳答案   
问题太多了，实在是改不过来！！！！！

问题帮你注释了，真的是没法改。帮你修改的时间就可以重新写一个了
  1. //将两个链表连接起来
  2. #include <stdio.h>
  3. #include <malloc.h>

  5. #define LEN sizeof(List) //这个定义是一个List node 的大小，并不是List长度

  7. typedef struct node
  8. {
  9.     int data;
  10.     struct node *next;
  11. } List;

  13. int main()
  14. {
  15.     // 首先得到m和n的值
  16.     int m, n;
  17.     int count1, count2;
  18.     printf("请输入两个链表的长度m与n：");
  19.     scanf("%d %d", &m, &n);
  20.     List *L1;
  21.     List *L2;
  22.     L1 = NULL;
  23.     L2 = NULL;
  24.     List *ha, *hb, *hc;
  25.     //ha = (List*)malloc(LEN); //这样分配的空间只能存储一个List node. 下同
  26.     //hb = (List*)malloc(LEN);
  27.     //hc = (List*)malloc(LEN);

  29.     ha = (List *)malloc(m * LEN); //这样分配的才是m个结点的List,下同
  30.     hb = (List *)malloc(n * LEN);
  31.     hc = (List *)malloc((m + n) * LEN);

  33.     //ha = L1; //这三步执行完 ha = NULL, ha = NULL, hc = NULL,
  34.     //所以后面对ha,hb,hc的操作都是对NULL指针所指空间的操作，当然segmentation fault
  35.     //hb = L2;
  36.     //hc = L1;
  37.     L1 = ha;
  38.     L2 = hb;
  39.     hc = L1; // hc现在和L1指向同一个空间，上面为hc分配的空间就此放弃，永远也访问不到了！！！！！！

  41.     count1 = 0;
  42.     while (count1 < m) // count1没有赋初值，虽然大多数情况下默认值是0，但这样很不安全
  43.     {
  44.         scanf("%d", &ha->data);
  45.         ha = ha->next;  //上面只是分配了存储List的空间，但是并没有建立处理链表结构，这是，ha->next的值并真的就是用空间。你这样做ha第二个往后的结点就访问不到了d//
  46.         count1++;
  47.     }
  48.     hb = ha; //hb和ha指向同一空间，
  49.     free(ha); // free(ha)，相当于把hb,和 ha指向的那个结点空间释放了，那么hb,和ha指针都悬空了。你这样做ha第二个往后的结点就访问不到了
  50.               //执行完这一步， hb指向的空间已经被free了， 那么下面对hb的访问也就segmentation fault了
  51.               // 就算上面的都没问题了，当跳出上面的while时，ha指向的是L1的最后一个结点之后的结点， 下面的while访问hb时访问的就是个没有分配的空间
  52. //
  53.     while (count2 < n)
  54.     {
  55.         scanf("%d", &hb->data);
  56.         hb = hb->next;
  57.         count2++;
  58.     }
  59.     hb = NULL; //这种赋值没有必要的，并不能节省空间
  60.     // 到目前为止，没看到链表拼接的任何操作
  61.     while (L1 != NULL) //这个循环永远不会结束。L1的值在整个循环中不会改变，也永远不可能等于NULL
  62.     {
  63.         do
  64.         {
  65.             printf("%d->",hc->data);
  66.             hc = hc->next;
  67.         } while (hc != NULL);
  68.         // 这个内层循环跳出后会在外层while中一直空转。你这内层循环和外层循环有什么关系吗。
  69.     }

  71.     return 0;
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

4goodworld
发表于 2020-3-3 23:55:09 | 显示全部楼层
链表不是很熟练，帮人就是帮己，让自己练习下，写错也请指正，感谢！
  1. #include<stdio.h>
  2. #include<malloc.h>
  3. #define LEN sizeof(List)

  5. typedef struct node {
  6.         int data;
  7.         struct node * next;
  8. }List;

  10. int main()
  11. {
  12.         // 首先得到m和n的值
  13.         int m, n;
  14.         int count1,count2;
  15.         count1 = count2 = 0;

  17.         printf("请输入两个链表的长度m与n：");
  18.         scanf("%d %d", &m, &n);
  19.         List * L1;
  20.         List * L2;//两串需要串联的列表
  21.         L1 = NULL;
  22.         L2 = NULL;//指针初始化
  23.         List *ha, *hb, *Head;


  26.          ha = (List*)malloc(LEN);//给指针分配内存
  27.          Head =hb= NULL;
  28.         while (count1 < m)//当读数小于m值时，继续读数进L1表
  29.         {
  30.                 count1++;
  31.                 printf("请输入链表%d data：\n",count1);
  32.                 scanf("%d", &ha->data);
  33.                 if (count1 == 1)Head = ha;
  34.                 else  hb->next=ha;
  35.                 hb = ha;
  36.                 ha = (List*)malloc(LEN);
  37.         }
  38.         hb ->next = NULL;
  39.         L1 = Head;


  42.         ha = (List*)malloc(LEN);//给指针分配内存
  43.         Head = hb = NULL;
  44.         while (count2 < n)
  45.         {
  46.                 count2++;
  47.                 printf("请输入链表2data：\n");
  48.                 scanf("%d", &ha->data);
  49.                 if (count2 == 1)Head = ha;
  50.                 else  hb->next = ha;
  51.                 hb = ha;
  52.                 ha = (List*)malloc(LEN);
  53.         }
  54.         hb->next = NULL;
  55.         L2= Head;

  57.         Head = L1;
  58.         printf("%d %d\n", L1, L2);
  59.         do{
  60.                 printf("%x", L1->next);
  61.                 if (L1->next == NULL) {
  62.                         L1->next = L2;
  63.                         break;
  64.                 }
  65.                 L1 = L1->next;       
  66.         } while (L1 != NULL);
  67.         L1 = Head;

  69.         while (L1 != NULL)
  70.         {
  71.                 printf("打印合并的效果：\n");
  72.                 do {
  73.                         printf("%d->", L1->data);
  74.                         L1 = L1->next;
  75.                 } while (L1 != NULL);
  76.         }
  77.         /*
  78.         free
  79.        
  80.         */
  81.         return 0;
  82. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 1 反对 0

使用道具 举报

major_lyu
发表于 2020-3-4 00:46:41 | 显示全部楼层
给你写了一个，看看是不是你想要的。


  2. //合并两个链表
  3. #include <stdio.h>
  4. #include <malloc.h>

  6. typedef struct node
  7. {
  8.     int data;
  9.     struct node *next;
  10. } List;

  12. //合并连个list L1 和 L2
  13. List *mergeList(List *L1, List *L2)
  14. {
  15.     //两个空链表直接返回空链表
  16.     if (L1 == NULL && L2 == NULL)
  17.         return NULL;
  18.     // 第一个链表为空，直接返回第二链表
  19.     if (L1 == NULL)
  20.         return L2;
  21.     // 第二链表为空，直接返回第一个链表
  22.     if (L2 == NULL)
  23.         return L1;
  24.     //如果两个链表都不为空，进行合并
  25.     List *rslt = (List *)malloc(sizeof(List));
  26.     List *ptr = rslt;
  27.     //复制第一个链表到结果链表
  28.     while (L1 != NULL)
  29.     {
  30.         ptr->data = L1->data;
  31.         ptr->next = (List *)malloc(sizeof(List));
  32.         ptr = ptr->next;
  33.         L1 = L1->next;
  34.     }
  35.     //复制第二个链表的数据建立后续结点
  36.     while (L2->next != NULL)
  37.     {
  38.         ptr->data = L2->data;
  39.         ptr->next = (List *)malloc(sizeof(List));
  40.         ptr = ptr->next;
  41.         L2 = L2->next;
  42.     }
  43.     ptr->data = L2->data;
  44.     ptr->next = NULL;
  45.     return rslt;
  46. }

  48. void printList(List *list) // 打印List
  49. {
  50.     while (list != NULL)
  51.     {
  52.         printf("%d->", list->data);
  53.         list = list->next;
  54.     }
  55.     printf("NULL\n");
  56. }

  58. //从终端读取n个整数构建链表
  59. List *constructList(int n)
  60. {
  61.     if (n == 0)
  62.         return NULL;
  63.     List *list = (List *)malloc(sizeof(List));
  64.     List *ha = list;
  65.     printf("Please input %d integers to construct list:\n", n);
  66.     while (n > 1)
  67.     {
  68.         scanf("%d", &ha->data);
  69.         ha->next = (List *)malloc(sizeof(List));
  70.         ha = ha->next;
  71.         n--;
  72.     }
  73.     scanf("%d", &ha->data);
  74.     ha->next = NULL;
  75.     return list;
  76. }

  78. int main()
  79. {
  80.     int m, n;
  81.     printf("Please input the length of two lists:\n");
  82.     scanf("%d %d", &m, &n);
  83.     List *L1 = constructList(m);
  84.     List *L2 = constructList(n);
  85.     List *L3 = NULL;
  86.     printList(L1);
  87.     printList(L2);
  88.     L3 = mergeList(L1, L2);
  89.     printList(L3);

  91.     return 0;
  92. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 1 反对 0

使用道具 举报

Shaky_00
 楼主| 发表于 2020-3-4 01:44:38 | 显示全部楼层
_谪仙 发表于 2020-3-3 23:27
链表初始化并不是一个NULL，而是一个空链表，还有你创建的节点空间都被覆盖掉了

感谢！！可以大概讲一下是哪个地方覆盖掉的吗？
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Shaky_00
 楼主| 发表于 2020-3-4 01:48:29 | 显示全部楼层
major_lyu 发表于 2020-3-4 00:46
给你写了一个，看看是不是你想要的。

好的，谢谢你！！
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Shaky_00
 楼主| 发表于 2020-3-4 01:49:27 | 显示全部楼层
4goodworld 发表于 2020-3-3 23:55
链表不是很熟练，帮人就是帮己，让自己练习下，写错也请指正，感谢！

谢谢你，我也好好学习一下！
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-7-6 12:45

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表