C 如何在冒泡排序算法中交换链表的节点？

在C语言中，我必须编写一个冒泡排序函数，交换节点，而不是LinkedList的值，但我无法完成它。以下是代码（您可以看到顺序不正确）：

#包括
#包括//malloc，免费
#include//NULL
//将“int”定义为数据
typedef int data_t；
类型定义结构节点{
数据；
结构节点*next；
}节点t；
节点\u t**列表\u新建（）{
节点**列表=malloc（大小**列表）；
如果（！list）返回空值；
*列表=空；
退货清单；
}
作废列表\u删除（节点**列表）{
node_t*node，*下一步；
for（节点=*列表；节点；节点=下一个）{
下一步=节点->下一步；
自由（节点）；
}
}
节点*列表\推送\前端（节点**列表，数据）{
node_t*node=malloc（sizeof（node_t））；
如果（！node）返回NULL；
节点->数据=数据；
节点->下一步=*列表；
返回*列表=节点；
}
//很容易交换值
/*
无效交换（数据交换*a、数据交换*b）{
数据c=*a；
*a=*b；
*b=c；
}
无效简单气泡排序（节点**列表）{
对于（节点\u t*i=*列表；i；i=i->next）
用于（节点\u t*j=*列表；j->next；j=j->next）
如果（j->data>j->next->data）
交换（&（j->data），&（j->next->data））；
}
*/
//交换节点就不那么容易了
无效交换节点（节点**上一个节点A、节点**节点A、节点**节点B）{
node_t*last_node=（*node_B）->next；
node_t*first_node=*node_A；
node_t*second_node=*node_B；
if（上一个节点）{
（*prev_node_A）->next=第二个_节点；
（*prev_node_A）->next->next=第一个_节点；
（*prev_node_A）->next->next->next=last_node；
}否则{
（*节点A）=第二个节点；
（*节点A）->next=第一个节点；
（*node_A）->next->next=last_节点；
}
}
无效简单气泡排序（节点**列表）{
用于（节点\u t*i=*列表；i->next；i=i->next）
对于（节点j=*列表；j->next->next；j=j->next）{
如果（j==*列表）{
如果（j->data>j->next->data）{
*list=j->next；
交换节点（NULL，&j，&（j->next））；
}
}
否则{
如果（j->next->data>j->next->next->data）
交换节点（&j，&（j->next），&（j->next->next））；
}
//printf（“%i，%i |%i，%i，%i，%i\n”，i->data，j->data，（*list）->data，（*list）->next->data，（*list）->next->data，（*list）->next->data，（*list）->next->data，（*list）->next->data）；
//系统（“暂停”）；
}
}
int main（）{
//创建列表
node_t**list=list_new（）；
如果（！列表）
转到内存分配失败；
//向列表中添加值
用于（整数i=0；不精确）
printf（“%i\n”，节点->数据）；
//交换测试
//交换节点（NULL，&（*list），&（（*list）->next）；
//交换节点（&（*list），&（（*list）->next），&（（*list）->next->next）；
//排序表
printf（“--冒泡排序--\n”）；
简单气泡排序（列表）；
//打印列表
对于（node_t*node=*list；node！=NULL；node=node->next）
printf（“%i\n”，节点->数据）；
//删除列表
列表\删除（列表）；
返回0；
//错误处理程序
内存分配失败：
printf（“内存分配失败”）；
返回1；
}

这是功能

交换

 void swap( node_t **current )  
 {  
     node_t *tmp = ( *current )->next->next;  

     ( *current )->next->next = *current;  


     *current = ( *current )->next;  

     ( *current )->next->next = tmp;  
 }  

下面是函数

simple\u bubble\u sort

 void simple_bubble_sort( node_t **head )  
 {  
     if ( *head )  
     {  
         for ( node_t **first = head, *sorted = NULL, *last = sorted;  
               ( *first )->next != last;  
               last = sorted )  
         {  
             sorted = ( *first )->next; 
             for ( node_t **current = first; ( *current )->next != last; current = &( *current )->next )  
             {  
                 if ( ( *current )->next->data < ( *current )->data )  
                 {  
                     swap( current );  

                     sorted = ( *current )->next;  
                 }  
             }  
         }  
     }  
 }  

没有道理，应该将其删除

你需要的只是定义一个指针，比如

node_t *head = NULL;

并将其传递给函数，例如传递给函数

simple\u bubble\u sort

like

simple_bubble_sort( &head );

或者功能

list\u push\u front

的定义如下

int list_push_front(node_t** list, data_t data) 
{
    node_t* node = malloc(sizeof(node_t));
    int success = node != NULL;

    if ( success )
    {
        node->data = data;
        node->next = *list;
        *list = node;
    }

    return success;;
}

---

很抱歉我的意思是，这是一个基于问题措辞的笑话。我只是想知道是否有可能让header

swap（node\u t*current）

通过引用调用

swap（¤t）

，并相应地更改里面的代码？@Katsu我不明白你在问什么。我展示了函数交换。问题是什么？我只是试着理解指向指针的指针，看看什么时候有必要或不需要使用它，以及是否可以通过使用引用来避免它。@Katsu在C中没有引用。在C中，通过引用传递意味着将指针传递给对象。如果对象本身是指针，则必须将指针传递给指针。

simple_bubble_sort( &head );

int list_push_front(node_t** list, data_t data) 
{
    node_t* node = malloc(sizeof(node_t));
    int success = node != NULL;

    if ( success )
    {
        node->data = data;
        node->next = *list;
        *list = node;
    }

    return success;;
}