Question

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

我能够成功编译并运行代码。我一步一步地追踪程序超过四次，但无法找到捕获。

我的意思是“在链接列表中分隔偶数和奇数节点”

输入：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

我是如何解决问题的：

temp：遍历列表。

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

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

oddPtrStart：跟踪奇数数据节点的启动。

我的功能如下：

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


}

使用head = segregateEvenOddNodesSLL（head）;

调用该函数

与往常一样，单链表的结构是：

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;

以下是我发现这一点的方法：

编译器应该警告您忘记初始化这些值。
单步执行，你应该立即注意到，只要你进入while循环，oddPtr和/或evenPtr就不会为空。

Answer 2

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

完成后，如果这......

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

...永远不会到达break以触发循环退出，并且您永远不会遇到分段错误或其他内存访问错误，那么最可能的解释是您的链接列表是循环的。您可以通过在每次迭代时打印当前节点的data来了解自己。

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

Answer 3

这是一个使用列表构建器生成初始和偶数/奇数列表的解决方案。我使用过轻微的欺骗行为＃34; - 列表最简单地按相反顺序制作，因此制作次要偶数和奇数列表，将它们反转为原始顺序。

另一种方法可能是在原始列表上进行冒泡排序，交换数据字段，如果“奇怪”的话。在“甚至”之前出现，但这个答案试图贴近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

无法退出while循环

3 个答案: