冒泡排序方法不适用于C中的链表

我试图在链表数据结构中实现一个冒泡排序方法，但是当通过测试工具运行它时，它什么也做不了。有什么建议吗

以下是我的源代码：

void set_sort (set_t * the_set)
{
    assert (the_set);
    set_node_t *current;
    current = the_set->head;
    int sorted = 1;
    int x;
    for (x = 0; x < the_set->set_size; x++) {
        //we dont do it if this is the last value
        if (x + 1 == the_set->set_size) {
            continue;
        }
        if (current->data > current->next->data) {
            sorted = 0;
            int temp = &current->next->data;
            current->next->data = current->data;
            current->data = temp;
        }
        current = current->next;
    }
    if (!sorted) {
        set_sort (the_set);
    }

}

void set\u排序（set\t*the\u set）
{
断言（_集）；
将节点设置为当前；
当前=设置->头部；
int=1；
int x；
对于（x=0；xset_size；x++）{
//如果这是最后一个值，我们不会这样做
如果（x+1==设置大小->设置大小）{
继续；
}
如果（当前->数据>当前->下一步->数据）{
排序=0；
int temp=&当前->下一步->数据；
当前->下一步->数据=当前->数据；
当前->数据=温度；
}
当前=当前->下一步；
}
如果（！已排序）{
集合排序（集合）；
}
}

用头文件编辑

#ifndef _set_h_
#define _set_h_

#include <stdbool.h>
#include "common.h"

/* Create a basic singly-linked list.*/
/*This code has been sourced from Mike Mcallistar, Assignment 5 Solutions*/

typedef struct _set_node_t {
        test_type_t *data;
        struct _set_node_t *next;
        struct _set_node_t *below;
} set_node_t;

/* the set itself keeps track of the head and the tail of the linked list */
typedef struct {

        int set_size;
        bool ready;
        set_node_t *head;
        set_node_t *tail;
        int set_level;
} set_t;


bool set_init(set_t *the_set);
void set_destroy(set_t *the_set);
bool set_add(set_t *the_set, test_type_t *item_to_add);
bool set_delete(set_t *the_set, test_type_t *item_to_remove);
bool set_find( set_t *the_set, test_type_t *item_to_find);
void set_sort(set_t *the_set);
void set_enumerate(set_t *the_set);
#endif

\ifndef\u set\u h_
#定义_集_h_
#包括
#包括“common.h”
/*创建一个基本的单链表*/
/*此代码来源于Mike Mcallistar，作业5解决方案*/
类型定义结构集节点{
测试类型数据；
结构设置节点下一步；
下面的结构集节点；
}设置节点；
/*集合本身跟踪链表的头和尾*/
类型定义结构{
int set_大小；
布尔就绪；
设置节点头；
设置_节点_t*tail；
int集_级；
}设置;；
bool set_init（set_t*the_set）；
无效集合销毁（集合*集合）；
bool集合添加（集合*集合，测试类型*项目添加）；
bool set_delete（set_t*要删除的项集、测试类型）；
bool set_find（set_t*测试集、测试类型_t*项目_to_find）；
无效集合排序（集合*集合）；
无效集合枚举（集合*集合）；
#恩迪夫

这似乎有点不对劲

int temp = &current->next->data;     // Assignes a pointer into temp
current->next->data = current->data; // Copies current into next
current->data = temp;                // Copies the pointer into data 

这不太可能什么都不做。很可能会损坏您的数据

是否可以简单地将第一行更改为：

int temp = current->next->data;

编辑

稍微整理一下你的代码，我想说：

void set_sort(set_t *the_set)
{
    assert(the_set);
    int sorted;
    int x;
    do {
        set_node_t *current = the_set->head;
        sorted = 1;
        for( x = 0; x < the_set->set_size - 1; x++){
            if(current->data > current->next->data){
                sorted = 0;
                int temp = current->next->data;
                current->next->data = current->data;
                current->data = temp;
            }
            current = current->next;
        }
    }
    while (!sorted);
}

---

如果您不需要使用

bubblesort

进行分配，请注意它是您可以选择的效率最低的排序例程之一<代码>快速排序或

合并排序

的效率要高得多。（对于超过16个左右的元素）很抱歉，我已经用了2个小时的时间来研究这个方法，我的格式设置变得非常草率。我会安排下一个time@DavidC.Rankin虽然主观，但这基本上是正确的。它非常擅长对大部分已排序的列表进行排序，在一个大列表中只有几行不合适。“除此之外，正如你所指出的，它可以相当容易地被打败。”库林同意。小于100左右的气泡过滤器的效率差别不大，但在这之后，其效率与其他过滤器相比会迅速下降。当你达到250000个元素时，它比其他元素慢几个数量级。如果您查看

qsort

的GNU源代码，您将看到它使用了混合

快速排序

和

合并排序

例程。IIRC它对少于16个元素使用mergesort，对以上所有元素使用quicksort。苹果在其

qsort

算法中使用了更多的直接

quicksort

。谢谢你帮我清理了这个问题，我现在明白了如何压缩上述代码的某些方面。Sort仍然没有做任何事情，我将编辑我上面的帖子来添加我的整个头文件（节点和集合结构的定义），如果

数据
是指针，那么您将比较指针而不是实际数据。@user1034749我会做些什么来显示这一点？我想如果您将上面答案中的代码替换为
If（*（当前->数据）>*（当前->下一步->数据）
并在交换值的代码中使用
*
，则所有值都应正常工作。每个内部循环都会将最大值移动到列表的末尾，因此可以在启动外部循环之前将最大计数器设置为设置_计数，并在每个内部循环之前递减。|max_count=_集->设置_大小；|……|是否执行{…| max_count--| for（x=0；xif(*(current->data) > *(current->next->data)){