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

Posted

技术标签:

【中文标题】如何在冒泡排序算法中交换链表的节点?【英文标题】:How do I swap the nodes of a linked list in a bubble-sort algorithm? 【发布时间】:2020-08-04 17:40:31 【问题描述】:

在 C 中,我必须编写一个冒泡排序函数,该函数交换 LinkedList 的节点而不是值,但我无法完成它。这是代码(如您所见,顺序不正确):

#include <stdio.h>
#include <malloc.h> // malloc, free
#include <stddef.h> // NULL

// defining 'int' as data_t
typedef int data_t;

typedef struct node_s 
    data_t data;
    struct node_s* next;
 node_t;

node_t** list_new() 
    node_t** list = malloc(sizeof **list);
    if (!list) return NULL;
    *list = NULL;
    return list;


void list_delete(node_t** list) 
    node_t *node, *next;
    for (node = *list; node; node = next) 
        next = node->next;
        free(node);
    


node_t* list_push_front(node_t** list, data_t data) 
    node_t* node = malloc(sizeof(node_t));
    if (!node) return NULL;
    node->data = data;
    node->next = *list;
    return *list = node;


// IS EASY TO SWAP THE VALUES
/*
void swap(data_t* a, data_t* b) 
    data_t c = *a;
    *a = *b;
    *b = c;


void simple_bubble_sort(node_t** list) 
    for(node_t* i = *list; i; i = i->next)
        for(node_t* j = *list; j->next; j = j->next)
            if(j->data > j->next->data)
                swap(&(j->data), &(j->next->data));


*/
// MUCH LESS EASY TO SWAP THE NODES
void swap_node(node_t** prev_node_A, node_t** node_A, node_t** node_B) 
        node_t *last_node = (*node_B)->next;
        node_t *first_node = *node_A;
        node_t *second_node = *node_B;
        if (prev_node_A) 
            (*prev_node_A)->next = second_node;
            (*prev_node_A)->next->next = first_node;
            (*prev_node_A)->next->next->next = last_node;
         else 
            (*node_A) = second_node;
            (*node_A)->next = first_node;
            (*node_A)->next->next = last_node;
        


void simple_bubble_sort(node_t** list) 

    for(node_t* i = *list; i->next; i = i->next)
        for (node_t *j = *list; j->next->next; j = j->next) 
            if (j == *list) 
                if (j->data > j->next->data) 
                    *list = j->next;
                    swap_node(NULL, &j, &(j->next));
                
            
            else 
                if (j->next->data > j->next->next->data)
                    swap_node(&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->next->data, (*list)->next->next->next->data);
            //system("pause");
        



int main() 
    // Create List
    node_t** list = list_new();
    if (!list)
        goto memory_allocation_failure;

    // Add values to List
    for(int i=0; i<10; i++)
        if (!list_push_front(list, i))
            goto memory_allocation_failure;

    // Print List
    for (node_t* node = *list; node != NULL; node = node->next)
        printf("%i\n", node->data);

    // Swap Test
    //swap_node(NULL, &(*list), &((*list)->next));
    //swap_node(&(*list), &((*list)->next), &((*list)->next->next));

    // Sort List
    printf("-- Bubble Sort --\n");
    simple_bubble_sort(list);

    // Print List
    for (node_t* node = *list; node != NULL; node = node->next)
        printf("%i\n", node->data);

    // Delete List
    list_delete(list);
    return 0;

    // Error Handler
    memory_allocation_failure:
        printf("Memory Allocation Failure");
        return 1;

【问题讨论】:

对不起。我的意思是根据问题的措辞开玩笑。 【参考方案1】:

这里是函数swap

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

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


     *current = ( *current )->next;  

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

这里是函数simple_bubble_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;  
                   
               
           
       
   

调查他们。

注意头文件&lt;malloc.h&gt;不是标准的C头文件。而是使用标题&lt;stdlib.h&gt;

您需要修改当前代码。比如这个函数

node_t** list_new() 
    node_t** list = malloc(sizeof **list);
    if (!list) return NULL;
    *list = NULL;
    return list;

没有意义,应该删除。

你需要的只是在 main 中定义一个类似的指针

node_t *head = NULL;

并将其传递给函数,例如传递给函数simple_bubble_sort 之类的

simple_bubble_sort( &head );

或者函数list_push_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;;

【讨论】:

我只是想知道是否有可能有标题swap( node_t *current)并通过引用调用swap(&amp;current)并相应地更改里面的代码? @Katsu 我不明白你在问什么。我展示了函数交换。有什么问题? 我只是尝试理解指向指针的指针,看看何时需要或不使用它,以及是否可以通过使用引用来避免它。 @Katsu 在 C 中没有引用。在 C 中通过引用传递意味着将指针传递给对象。如果对象本身是一个指针,那么你必须将指针传递给指针。 ok thanks

以上是关于如何在冒泡排序算法中交换链表的节点?的主要内容,如果未能解决你的问题,请参考以下文章

链表的冒泡排序算法

链表排序(冒泡选择插入快排归并希尔堆排序)

从数组冒泡排序迁移到链表冒泡排序

链表选择排序的C语言算法实现

经典算法学习——链表实现冒泡排序

排序算法之交换排序(冒泡排序快速排序)