[已解决]各位大佬想问一下，我这个元素不存在的时候为什么没办法正常运行

Christopher.

//4.屏幕提示后，在以DLList1为头指针的线性表中搜索这个元素key，并给出相应的位置或不存在
void search(Node *DLList1,int key)
{
        Node *p;
        int i=0;
        int flag=1;
       
        p=DLList;
       
        while(p)
        {
                p=p->next;
                i++;
                if(p->data == key)
                {
                        flag=0;
                        break;
                }
        }
       
        if(flag)
        {
                printf("元素不存在！");
                wait();
                return;
        }
        else{
                printf("元素所在位置为：%d",i);
                wait();
        }
       
}

最佳答案

月排行榜 / 总排行榜

sunrise085

2020-9-17 22:07:44

Christopher. 发表于 2020-9-17 20:09
对，调试可以通过，但是输一个链表里不存在的，无法正常运行出结果

你把search那个函数的while循环条件改为 while(p->next) 就可以了

跳转到最佳答案楼层

孟婆汤

贴一下完整代码看看，感觉是死循环了

Christopher.

孟婆汤 发表于 2020-9-17 19:27
贴一下完整代码看看，感觉是死循环了

好的

Christopher.

#include <conio.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
struct Node{
                int data;
                Node *next;
                };

Node Head;       //头结点
Node *DLList;    //头指针
void init(Node *DLList);
void display(Node *DLList);
void insert(Node *DLList1,int,int);
void search(Node *DLList1,int);
void del(Node *DLList1,int);

int main()
{
        char choice;
        int wz,key;
    key=0;
        DLList=&Head;     //使头指针指向头结点
        Head.next=NULL;

        while (1)
        {
                system("cls");
   
                printf("\n\n\n\n");                             
                printf("\t\t              单链表操作  \n");
                printf("\t\t======================================");
                printf("\n\n");
                printf("\t\t             1：初始化      \n");
                printf("\t\t             2：显示        \n");
                printf("\t\t             3：单个插入    \n");
                printf("\t\t             4：查找        \n");
                printf("\t\t             5：删除        \n");
                printf("\t\t             0：退出        \n");
                printf("\n");
                printf("\t\t请选择：" );

                choice = getch();
                system("cls");
               
                switch(choice)
                {
                        case '1':
                            //调用实现函数
                            init(DLList);
                                break;
                        case '2':
                            //调用实现函数
                            display(DLList);
                                break;
                        case '3':
                //位置wz,需插入的数key
                       
                                break;
                        case '4':
                                //请输入需要查找的数key
                            //调用实现函数
                                break;
                        case '5':
                                //请输入需要删除的数
                            //调用实现函数
                                break;
                        case '0':
                                exit(0);
                }
        }
        return 0;
}

//公用的等待函数
void wait()
{
        printf("\n\n请按任意键继续\n");
        getch();
}

void init(Node *DLList)
{
        int length;
        Node *p,*q;
        while (1)
        {
                printf("输入元素个数（0－ 10000 ）：\n");
                scanf("%d",&length);
                if (length >= 0 && length <= 10000)
                        break;
                printf("\n");
        }

    int i;
        while (1)
        {
                printf("输入随机数种子（0－32767）：\n");
                scanf("%d",&i);
                if (i >= 0 && i <= 32767)
                        break;
                printf("\n");
        }

    //从线性表中删除并释放原有的结点，使其成为空表
        p=DLList;
        while (p->next!=NULL)
        {
                q=p->next;
                p->next=q->next;
                free(q);
        }

        srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
        rand();  

        //向线性表插入length个新结点
    for (int j=1;j<=length;j++)   
    {
                p=new Node;
                p->next=DLList->next;
                DLList->next=p;
                p->data=rand() % 10000;
    }
}

void display(Node *DLList)
{
        Node *p;
        int count=0;
        p=DLList;
        p=p->next;            //头结点未初始化，值自动为0，需要跳过头结点
       
        while(p)
        {
                printf("%d ",p->data);
                p=p->next;
                count++;
        }
       
        printf("\n");
        printf("元素个数：%d",count);
       
        wait();
}


//4.屏幕提示后，在以DLList1为头指针的线性表中搜索这个元素key，并给出相应的位置或不存在
void search(Node *DLList1,int key)
{
        Node *p;
        int i=0;
        int flag=1;
       
        p=DLList;
       
        while(p&&)
        {
                p=p->next;
                i++;
                if(p->data == key)
                {
                        flag=0;
                        break;
                }
        }
       
        if(flag)
        {
                printf("元素不存在！");
                wait();
                return;
        }
        else{
                printf("元素所在位置为：%d",i);
                wait();
        }
       
}

孟婆汤

1. #include <conio.h>
   
2. #include <stdio.h>
   
3. #include <process.h>
   
4. #include <string.h>
   
5. #include <math.h>
   
6. #include <stdlib.h>
   
7. typedef struct Node {
   
8.         int data;
   
9.         Node *next;
   
10. }Node;
    
11. 
    
12. Node Head;       //头结点
    
13. Node *DLList;    //头指针
    
14. void init(Node *DLList);
    
15. void display(Node *DLList);
    
16. void insert(Node *DLList1, int, int);
    
17. void search(Node *DLList1, int);
    
18. void del(Node *DLList1, int);
    
19. 
    
20. int main()
    
21. {
    
22.         char choice;
    
23.         int wz, key;
    
24.         key = 0;
    
25.         DLList = &Head;     //使头指针指向头结点
    
26.         Head.next = NULL;
    
27. 
    
28.         while (1)
    
29.         {
    
30.                 system("cls");
    
31. 
    
32.                 printf("\n\n\n\n");
    
33.                 printf("\t\t              单链表操作  \n");
    
34.                 printf("\t\t======================================");
    
35.                 printf("\n\n");
    
36.                 printf("\t\t             1：初始化      \n");
    
37.                 printf("\t\t             2：显示        \n");
    
38.                 printf("\t\t             3：单个插入    \n");
    
39.                 printf("\t\t             4：查找        \n");
    
40.                 printf("\t\t             5：删除        \n");
    
41.                 printf("\t\t             0：退出        \n");
    
42.                 printf("\n");
    
43.                 printf("\t\t请选择：");
    
44. 
    
45.                 choice = getchar();
    
46.                 system("cls");
    
47. 
    
48.                 switch (choice)
    
49.                 {
    
50.                 case '1':
    
51.                         //调用实现函数
    
52.                         init(DLList);
    
53.                         break;
    
54.                 case '2':
    
55.                         //调用实现函数
    
56.                         display(DLList);
    
57.                         break;
    
58.                 case '3':
    
59.                         //位置wz,需插入的数key
    
60. 
    
61.                         break;
    
62.                 case '4':
    
63.                         //请输入需要查找的数key
    
64.                 {
    
65.                         int c = 0;
    
66.                         printf("请插入需要查找的数字: ");
    
67.                         scanf_s("%d", &c);
    
68.                         search(DLList, c);
    
69.                         break;
    
70.                 }
    
71.                 //调用实现函数
    
72.                         break;
    
73.                 case '5':
    
74.                         //请输入需要删除的数
    
75.                 //调用实现函数
    
76.                         break;
    
77.                 case '0':
    
78.                         exit(0);
    
79.                 }
    
80.         }
    
81.         return 0;
    
82. }
    
83. 
    
84. //公用的等待函数
    
85. void wait()
    
86. {
    
87.         printf("\n\n请按任意键继续\n");
    
88.         getchar();
    
89.         getchar();
    
90. }
    
91. 
    
92. void init(Node *DLList)
    
93. {
    
94.         int length;
    
95.         Node *p, *q;
    
96.         while (1)
    
97.         {
    
98.                 printf("输入元素个数（0－ 10000 ）：\n");
    
99.                 scanf_s("%d", &length);
    
100.                 if (length >= 0 && length <= 10000)
     
101.                         break;
     
102.                 printf("\n");
     
103.         }
     
104. 
     
105.         int i;
     
106.         while (1)
     
107.         {
     
108.                 printf("输入随机数种子（0－32767）：\n");
     
109.                 scanf_s("%d", &i);
     
110.                 if (i >= 0 && i <= 32767)
     
111.                         break;
     
112.                 printf("\n");
     
113.         }
     
114. 
     
115.         //从线性表中删除并释放原有的结点，使其成为空表
     
116.         p = DLList;
     
117.         while (p->next != NULL)
     
118.         {
     
119.                 q = p->next;
     
120.                 p->next = q->next;
     
121.                 free(q);
     
122.         }
     
123. 
     
124.         srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
     
125.         rand();
     
126. 
     
127.         //向线性表插入length个新结点
     
128.         for (int j = 1; j <= length; j++)
     
129.         {
     
130.                 p = new Node;
     
131.                 p->next = DLList->next;
     
132.                 DLList->next = p;
     
133.                 p->data = rand() % 10000;
     
134.         }
     
135. }
     
136. 
     
137. void display(Node *DLList)
     
138. {
     
139.         Node *p;
     
140.         int count = 0;
     
141.         p = DLList;
     
142.         p = p->next;            //头结点未初始化，值自动为0，需要跳过头结点
     
143. 
     
144.         while (p)
     
145.         {
     
146.                 printf("%d ", p->data);
     
147.                 p = p->next;
     
148.                 count++;
     
149.         }
     
150. 
     
151.         printf("\n");
     
152.         printf("元素个数：%d", count);
     
153. 
     
154.         wait();
     
155. }
     
156. 
     
157. 
     
158. //4.屏幕提示后，在以DLList1为头指针的线性表中搜索这个元素key，并给出相应的位置或不存在
     
159. void search(Node *DLList1, int key)
     
160. {
     
161.         Node *p;
     
162.         int i = 0;
     
163.         int flag = 1;
     
164. 
     
165.         p = DLList;
     
166. 
     
167.         while (p != NULL)
     
168.         {
     
169.                 p = p->next;
     
170.                 i++;
     
171.                 if (p != NULL && p->data == key)
     
172.                 {
     
173.                         flag = 0;
     
174.                         break;
     
175.                 }
     
176.         }
     
177. 
     
178.         if (flag)
     
179.         {
     
180.                 printf("元素不存在！");
     
181.                 wait();
     
182.                 return;
     
183.         }
     
184.         else {
     
185.                 printf("元素所在位置为：%d", i);
     
186.                 wait();
     
187.         }
     
188. 
     
189. }

复制代码

孟婆汤

vs2017 调试通过

Christopher.

孟婆汤 发表于 2020-9-17 19:54
vs2017 调试通过

对，调试可以通过，但是输一个链表里不存在的，无法正常运行出结果

sunrise085

Christopher. 发表于 2020-9-17 20:09
对，调试可以通过，但是输一个链表里不存在的，无法正常运行出结果

你把search那个函数的while循环条件改为 while(p->next) 就可以了

风过无痕1989

喝多了，不便回复，你们聊

Christopher.

sunrise085 发表于 2020-9-17 22:07
你把search那个函数的while循环条件改为 while(p->next) 就可以了

对的，我后来改出来了

孟婆汤

Christopher. 发表于 2020-9-17 23:52
对的，我后来改出来了

没问题啊，我调试的就是不存在的一个值