C中带指针的冒泡排序单链表

Question

我正在尝试使用 C 中的指针操作对单链表进行冒泡排序。我在网站上查看了其他一些冒泡排序的实现，但我觉得这里的代码逻辑应该是有意义的。即便如此，还是进入了无限循环。任何帮助将不胜感激！

int counter;
struct node* current = head;
struct node* previous = (struct node*) malloc(sizeof(struct node));
struct node* next = (struct node*) malloc(sizeof(struct node));

for (counter = 0; counter < num_nodes; counter++){
    current = head;
    next = current->m_next;

    while(next != NULL){
        int compare = strcmp(current->m_last_name, next->m_last_name);
        if (compare > 0){
            if (current == head){
                head = next;
            }
            previous->m_next = next;
            current->m_next = next->m_next;
            next->m_next = current; 

            previous = next;
            next = current->m_next;
        }
        else {
            previous = current;
            current = current->m_next;
            next = current->m_next;
        }
    }
}
printf("Loop completely done\n");

}

Answer 1

这里有几个问题。首先，为什么要为next 和previous 节点指针分配内存？您正在排序，没有涉及新节点，您只是在调整现有节点之间的链接。更重要的是，您重新分配您拥有malloced 内存的指针，例如：

previous = current;

这意味着，previous 的值以及分配的内存都丢失了。

接下来，你的头指针很可能在排序后就不一样了。调用函数需要了解此更改。因此，您应该将指向节点指针的指针传递给排序函数。 （我相信您将 ndes 添加到列表的功能也可以做到这一点。）

previous 指针也是如此。如果这是一个节点指针，那就是：另一个指向同一个节点的指针。更新它时，会更新列表结构外部的指针。因此，previous 也应该是指向节点指针的指针。这个指针首先与指向头节点指针的指针相同，然后在遍历链表时指向前一个节点的next 指针。如果你更新prev 指向的指针，你就会更新列表结构中的指针，这就是你想要的。

此外，在您的代码中明确使用num_nodes 非常不像列表。您应该使用列表结构本身来编写算法。

死循环是由current 交换后没有正确更新引起的。鉴于对 malloced 指针的误解，我没有对此进行过多研究。

这是一个有效的实现：

void list_bubble_sort(struct node **head) 
{
    int done = 0;         // True if no swaps were made in a pass

    // Don't try to sort empty or single-node lists
    if (*head == NULL || (*head)->m_next == NULL) return;

    while (!done) {
        struct node **pv = head;            // "source" of the pointer to the
                                            // current node in the list struct
        struct node *nd = *head;            // local iterator pointer
        struct node *nx = (*head)->m_next;  // local next pointer

        done = 1;

        while (nx) {
            int cmp = strcmp(nd->m_last_name, nx->m_last_name);

            if (cmp > 0) {
                nd->m_next = nx->m_next;
                nx->m_next = nd;
                *pv = nx;

                done = 0;
            }
            pv = &nd->m_next;
            nd = nx;
            nx = nx->m_next;
        }
    }
}

请注意pv 始终包含指向nd 的内部指针的源，以及如何通过*head 指向头节点并非特殊情况。

算法从头到尾重复地传递列表，直到不需要进行任何更改。这有点粗略，但毕竟是冒泡排序。

编辑 在另一个答案中，aehrwyn 解释了为什么会出现无限循环。他的修复工作有效，但存在不必要地分配内存并且从未真正使用过的缺陷，更不用说释放它了。应用 aehrwyn 的发现，您的代码应如下所示：

struct node *bubble (struct node *head)
{
    int num_nodes = count(head);
    int counter;

    for (counter = 0; counter < num_nodes; counter++) {
        struct node* current = head;
        struct node* next = current->m_next;
        struct node* previous = NULL;

        while(next != NULL) {
            int compare = strcmp(current->m_last_name, next->m_last_name);
            if (compare > 0) {
                if (current == head){
                    head = next;
                } else {
                    previous->m_next = next;
                }
                current->m_next = next->m_next;
                next->m_next = current; 

                previous = next;
                next = current->m_next;
            }
            else {
                previous = current;
                current = current->m_next;
                next = current->m_next;
            }
        }
    }
    printf("Loop completely done\n");
    return head;
}

注意事项：

• 不需要 malloc 任何东西。指针next 和previous 只是没有正确数据的“工作指针”；它们指向现有节点。

• 我已将工作指针的定义移到外循环内。在我看来，这反映了它们的范围，并使诸如忘记重新设置它们之类的错误更容易被发现。

• 您分配previous->m_next。我认为您害怕取消引用 NULL 指针，因此分配了一个虚拟节点。相反，您应该在取消引用之前检查NULL。在您的代码中，条件previous != NULL 等同于current == head，因此分配给previous->m_next 可以发生在else 子句中。事实上，if/else 反映了两种基本情况：头节点和后续节点。

• 在我上面的（有点粗鲁的）解释中，我说过你应该使用指向节点的指针，但那是因为我认为你的代码来自一个单独的函数。但它可能是main 的一部分，所以使用简单的struct node * 是可以的。请注意，当您返回新的头节点时，这也适用于单独的函数。你必须调用你的函数：

  head = bubble(head);
  

  在我看来这很容易出错，因为忽略返回值是合法的。我更喜欢上面解释的双指针方法。 （旁注：我在 SO 上看到很多代码，这是一个很长的 main 函数。学习将代码拆分为可以重复使用的小型、独立的函数。起初可能看起来很乏味，但在从长远来看，这种编码风格会带来好处。）

Answer 2

除了其他人提到的不必要的mallocing之外，您的大部分代码都是正确的。

您进入一个无限循环只是因为您在进入下一个 for 循环迭代时没有重置“上一个”。所以，当你设置：

上一个->下一个 = 下一个；

previous 可能是列表中倒数第二个项目，这是您在最后一次 for 循环迭代中的 while 循环中设置的。要快速解决问题以查看问题所在，请将您的第 3 行替换为：

struct node* previousDummy = (struct node*) malloc(sizeof(struct node));
struct node* previous;

并在你的while循环之前添加这个：

previous = previousDummy;