无法退出while循环

Question

我试图编写一个名为“在链接列表中隔离偶数和奇数节点”的单链表列表程序，但无法退出while循环。

我能够成功地编译和运行代码。我一遍又一遍地追踪程序超过四次，但无法找到catch。

我的意思

输入 “在一个链表·隔离偶数和奇数节点”：17-> 15-> 8-> 12-> 10-> 5-> 4-> 1-> 7 - > 6-> NULL;输出：8-> 12-> 10-> 4-> 6-> 17-> 15-> 5-> 1→7-> NULL

输入：8-> 12-> 10-> 5- > 4-> 1-> 6-> NULL;输出：8-> 12-> 10-> 4-> 6-> 5-> 1-> NULL

如果所有的数字都是偶数则不要更改列表 输入：8-> 12-> 10- > NULL 输出：8-> 12-> 10-> NULL

如果所有数值是奇数那么不改变列表 输入：1-> 3-> 5-> 7-> NULL 输出：1 - > 3-> 5> 7> NULL

如何解决了这个问题：

温度：遍历列表。

evenPtr：指向偶数据节点的指针。

oddPtr：指向奇数据节点的指针。

oddPtrStart：跟踪奇数据节点的开始。

My功能低于：

struct node *segregateEvenOddNodesSLL(struct node *temp) 
{ 
    struct node *evenPtr,*oddPtr,*oddPtrStart,*head=NULL; 

    head=temp; 

    while(1) 
    { 
     if(((temp->data)%2)==0) // even 
     { 

      if(evenPtr==NULL) 
      { 
       head=temp; 
       evenPtr=temp; 
      } 
      else 
      { 
       evenPtr->link=temp; 
       evenPtr=temp; 
      } 


     } 

     else    // odd 
     { 
      if(oddPtr==NULL) 
      { 
       oddPtrStart=temp; 
       oddPtr=temp; 
      } 
      else 
      { 
       oddPtr->link=temp; 
       oddPtr=temp; 
      } 



     } 

     temp=temp->link; 
     if(temp==NULL) 
     { 
      break; 
     } 

     printf("\n Inside While.... \n"); 

    }// end of while. 

    if(evenPtr==NULL) 
    { 
     return head; 
    } 
    else if(oddPtr==NULL) 
    { 
     return head; 
    } 
    else 
    { 
     oddPtr->link=NULL; 
     evenPtr->link=oddPtrStart; 

     return head; 
    } 


} 

呼叫与头部= segregateEvenOddNodesSLL（头）的功能;

像往常一样单向链表的结构是：

struct node 
{ 
int data; 
struct node *link; 
}; 

Answer 1

检查以下行：

struct node *evenPtr,*oddPtr,*oddPtrStart,*head=NULL; 

需要是：

struct node *evenPtr=NULL,*oddPtr=NULL,*oddPtrStart=NULL,*head=NULL; 

这里是我发现这个：

1. 编译器应该给你一个警告，你忘记初始化这些值。
2. 单步执行时，您应立即注意到，while循环一到，oddPtr和/或evenPtr就不为空。

Answer 2

首先，您要在初始化变量之前测试变量evenPtr和oddPtr的值。看起来你想在进入循环之前将它们中的每一个初始化为NULL。

这样做，如果这...

temp=temp->link; 
    if(temp==NULL) 
    { 
     break; 
    } 

...永远不会到达break触发循环退出，你永远不会得到一个分割故障或其他内存访问错误，那么最可能的解释是，你的链表是圆形的。您可以通过在每次迭代中打印当前节点的data来解决这个问题。

请注意，循环后的代码有缺陷：如果列表中没有偶数项目，则所有节点都将丢失。

Answer 3

这是一个解决方案，它使用列表生成器来创建初始和偶数/奇数列表。我使用了一个轻微的“作弊” - 一个列表最简单的做法是以相反的顺序制作，所以制作第二个偶数和奇数列表，将它们反转到原始顺序。

另一种方法可能是在原始列表上进行气泡排序，如果'odd'出现在'even'之前，则交换数据字段，但这个答案试图贴近OP做的事情。

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

struct node { 
    int data; 
    struct node *link; 
}; 

struct node* add_node(struct node *list, int id) { 
    struct node *n = malloc(sizeof (struct node)); 
    if (n == NULL) { 
     printf("Fatal Error: Out of memory!\n"); 
     exit(1); 
    } 
    n->data = id; 
    n->link = list; 
    return n; 
} 

struct node *segregateEvenOddNodesSLL(struct node *temp) { 
    struct node *odd=NULL,*even=NULL, *last = NULL; 
    while(temp) { 
     if(((temp->data)%2)==0) {  // even 
      even = add_node (even, temp->data); 
      if (last == NULL) 
       last = even; 
     } 
     else 
      odd = add_node (odd, temp->data); 
     temp = temp->link; 
    } 
    if(even) { 
     last->link = odd;   // append odd list 
     return even; 
    } 
    return odd; 
} 

void show (struct node *list) { 
    printf("List: "); 
    while(list != NULL) { 
     printf("%3d", list->data); 
     list = list->link; 
    } 
    printf("\n"); 
} 

void free_list(struct node *list) { 
    struct node *tmp; 
    while (list) { 
     tmp = list->link;  
     free(list); 
     list = tmp; 
    } 
} 

void make_list(int *array, int elements) { 
    struct node *list = NULL, *newlist; 
    int i; 
    printf("Array:"); 
    for (i=0; i<elements; i++) { 
     printf ("%3d", array[i]);    // show unsorted array 
     list = add_node(list, array[i]);  // make the linked list 
    } 
    printf("\n"); 
    newlist = segregateEvenOddNodesSLL(list); // sort it 
    show (newlist);        // show sorted list 
    printf ("\n"); 
    free_list (list); 
    free_list (newlist); 
} 

int main(void) { 
    int data1[10] = { 17, 15, 8, 12, 10, 5, 4, 1, 7, 6 }; 
    int data2[7] = { 8, 12, 10, 5, 4, 1, 6 }; 
    int data3[3] = { 8, 12, 10 }; 
    int data4[4] = { 1, 3, 5, 7 }; 

    make_list(data1, 10); 
    make_list(data2, 7); 
    make_list(data3, 3); 
    make_list(data4, 4); 
    return 0; 
} 

程序输出：

Array: 17 15 8 12 10 5 4 1 7 6 
List: 8 12 10 4 6 17 15 5 1 7 

Array: 8 12 10 5 4 1 6 
List: 8 12 10 4 6 5 1 

Array: 8 12 10 
List: 8 12 10 

Array: 1 3 5 7 
List: 1 3 5 7