C语言版---双向循环链表排序，冒泡排序，选择排序，插入排序，快速排序，应有尽有，取之不尽用之不竭，交换节点版本，没有bug，保证看懂!

已于 2022-09-10 23:14:45 修改
阅读量2.9k 收藏 60
点赞数 18
分类专栏： 数据结构 文章标签： 数据结构 排序算法 c语言
于 2022-08-14 09:04:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AABond/article/details/126328003
版权

一、废话不多说，直接上代码

        如果想看单链表排序的朋友，可以在我的博客里找，点击左边。

你好

#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    int data;
    struct node *prev;
    struct node *next;
}node;

//生成一个节点
node *initList(void)
{
    node *new = malloc(sizeof(node));

    if(!new)
    {
        printf("malloc fail!\n");
        return NULL;
    }

    new->data = 0;
    new->prev = new;
    new->next = new;

    return new;
}

//头插法插入一个节点
void head_insert(node *head, node *new)
{
    new->next = head->next;
    head->next->prev = new;
    head->next = new;
    new->prev = head;
}
//尾插法插入一个节点
void tail_insert(node *head, node *new)
{
    new->prev = head->prev;
    head->prev->next = new;
    new->next = head;
    head->prev = new;
}

//弹出一个节点
void Remove(node *new)
{
    new->prev->next = new->next;
    new->next->prev = new->prev;
    new->next = new;
    new->prev = new;
}
//遍历
void traverse(node *head)
{
    for(node *p = head->next; p != head; p = p->next)
    {
        printf("%d ", p->data);
    }

    printf("\n");
}

//选择排序
void choose_sort(node *head)
{
    //头结点是空的或者表是空的或者表只有一个节点时候不用排
    if(!head || head->next == head || head->next->next == head) 
    {
        return;
    }
    
    node *p, *min, *tail;

    //tail及tail前面是排好序的，每次从tail后面选出一个最小值，插入到tail前面，直到等于head结束
    for(tail = head; tail->next != head; tail = tail->next)
    {
        //从tail->next->next开始，到等于head时结束，与tail->next比较找出最小值min
        for(min = tail->next, p = min->next; tail != head, p != head; p = p->next)
        {
            if(min->data > p->data) //找到一个比min更小的，就记录
            {
                min = p;       //由于是双向循环链表不需要记录min的前驱节点
            }
        }

        printf("本轮排序选择出的最小值： %d\n", min->data);
        
        if(min != tail->next)  //如果tail->next本来就是本轮的最小值，则不用交换
        {
            /*弹出min节点
            min->prev->next = min->next;
            min->next->prev = min->prev; */
            Remove(min);

            /*尾插法插到tail后面
            min->prev = tail;
            min->next = tail->next;
            tail->next->prev = min;
            tail->next = min;*/
            head_insert(tail, min);
        }

        traverse(head);   //显示每一轮排序结果
    }
}

//冒泡排序
void bubble_sort(node *head)
{
    int flag;
    node  *p, *tmp, *tail;

    tail = head;   //tail以及tail后面的是排好序的元素，第一次还没有排好，所以为head
    
    while(1)
    {
        flag = 1;   //flag用来标志是否已经排好序

        //每次从head->next开始遍历，直到tail结束, prev是p的前驱节点
        for(p = head->next; p && p->next != tail;)
        {
            //交换后，p已经移动到后面，不需要再遍历下一个
            if(p->data > p->next->data)
            {
                flag = 0;        //修改flag=0，标志本轮循环交换过
                tmp  = p->next;  //在弹出p节点前需先记录p->next节点

                /*弹出p节点
                p->prev->next = p->next;
                p->next->prev = p->prev;*/
                Remove(p);
                
                /*插入p节点
                p->next = tmp->next;
                tmp->next->prev = p;
                p->prev = tmp;
                tmp->next = p;*/
                head_insert(tmp, p);
            }
            else //没有交换就继续遍历下一个
            {
                p = p->next;
            }
        }

        printf("本轮排序移动出的最大值：%d\n", p->data);
        traverse(head);   显示每一轮排序结果

        if(flag)   //如果内层循环中都没有交换过，则所有节点都已经是排好序的
        {
            printf("冒泡排序结束！\n");
            break;
        }

        tail = p;  //tail向前移一个，tail以及tail后面的是排好序的元素
    }
}

//插入排序，最优版本
void insert_sort(node *head)
{
    //头结点是空的或者表是空的或者表只有一个节点时候不用排
    if(!head || head->next == head || head->next->next == head) 
    {
        return;
    }

    node *p, *q, *tail;

    //head->next->next开始遍历，tail及tail前面的是排好序的，p是本轮待插入值，等于head时结束
    for(tail = head->next, p = tail->next; p != head; p = tail->next)
    {
        //从head->next开始遍历，直到tail结束
        for(q = head; q != tail; q = q->next)
        {
            if(p->data < q->next->data) //插入后结束本次遍历
            {
                /*弹出p节点
                tail->next = p->next;
                p->next->prev = tail; */ 
                Remove(p);
                
                /*把p节点插入到q->next前面,即q的后面
                p->next = q->next;
                q->next->prev = p;
                q->next = p
                p->prev = q;*/
                head_insert(q, p);
                break;
            }
        }
        printf("本轮排序插入值：%d, ", p->data);
        if(tail == q)   //在tail前面没有插入，就下移
        {
            printf("已处于插入位置\n");
            tail = tail->next;
        }
        else
        {
            //p已经处于插入位置，显示时要用p->next->data
            printf("插入到%d的前面\n", p->next->data);
        }
        
        traverse(head);  //显示每一轮排序结果
    }
}

//快速排序的一次划分，第一种版本
node *partition(node *head, node *tail)
{
    node *p, *basic, *tmp;

    //从baisc后面开始遍历，找到比baisc小的就插入到head后面，直到tail结束，prev是p的前驱节点
    //这里head可以理解为本次待划分的链表的头结点，tail是链表的最后一个节点的下一个(NULL)
    for(basic = head->next, p = basic->next; p != tail; p = p->next)
    {
        if(p->data < basic->data)
        {
            //保留p->prev的位置, 交换后p要复位
            tmp = p->prev;

            /*弹出p节点
            p->next->prev = p->prev;
            p->prev->next = p->next;*/
            Remove(p);
            
            /*p节点插入到head后
            p->next = head->next;
            head->next->prev = p;
            p->prev = head;
            head->next = p;*/
            head_insert(head, p);

            //p复位
            p = tmp;
        }
    }

    return basic;
}

//快速排序，第一种版本
void quick_sort(node *head, node *tail)
{
    //头结点是空的或者表是空的或者表只有一个节点时候不用排
    //tail是链表的结束点，一开始等于head,后面等于basic
    if(!head|| head->next == tail || head->next->next == tail)
    {
        return;
    }
    //baisc前的节点都比basic小，baisc后的节点都比baisc大
    node *basic = partition(head, tail);
    printf("本次划分节点：%d\n", basic->data);

    quick_sort(head, basic); //把head->next到basic前一个进行递归排序
    quick_sort(basic, tail); //从basic->next到tail前一个进行递归排序
}

//交换两节点，p, q互换
void swap(node *p, node *q)
{
    if(p->data == q->data)
    {
        return;
    }

    node *tmp = p->prev;  //记录p的前驱节点

    Remove(p);            //弹出p节点
    head_insert(q, p);    //把p插入到q后面

    Remove(q);            //弹出q节点
    head_insert(tmp, q);  //把q插入到tmp后面
}

//快速排序的一次划分，第二种版本
node *partition2(node *head, node *tail)
{
    node *p, *q, *tmp;

    p = head->next; //这里head可以理解为本次待划分的链表的头结点
    q = tail->prev; //这里tail是链表的最后一个节点的后面，可以理解为NULL

    //区间长度等于零时结束
    //特别说明，内层循环中判断条件中，有且仅有一个内层循环要加“<=”号，二选一
    //内层循环只能是两个，如果是一个的话，会出错，举例：12 34 78 56 23 99 34 12 45 76
    while(p != q)
    {
        //从后面开始往前遍历，直到p==q或者p->data大于等于q->data
        while(p != q && p->data < q->data)
        {
            q = q->prev; 
        }

        if(p == q)   //如果p->data 都小于q->data，表示已经排好
        {
            break;
        }

        tmp = p->prev;    //交换前先保留p->prev，用来复位p 和 q
        swap(p, q);       //交换p和q
        q = p;            //q复位
        p = tmp->next;    //p复位

        //从前面开始往后遍历，直到p==q或者p->data大于q->data
        while(p != q && p->data <= q->data)
        {
            p = p->next;
        }

        if(p == q)   //如果p->data 都小于q->data，表示已经排好
        {
            break;
        }

        tmp = p->prev;   //交换前先保留p->prev，用来复位p 和 q
        swap(p, q);      //交换p和q
        q = p;           //q复位
        p = tmp->next;   //p复位
    }

    return p;
}

//快速排序，第二种种版本
void quick_sort2(node *head, node *tail)
{
    //头结点是空的或者表是空的或者表只有一个节点时候不用排
    //tail是链表的结束点，一开始等于head,后面等于basic
    if(!head|| head->next == tail || head->next->next == tail)
    {
        return;
    }
    //baisc前的节点都比basic小，baisc后的节点都比baisc大
    node *basic = partition2(head, tail);
    printf("本次划分节点：%d\n", basic->data);

    quick_sort2(head, basic); //把head->next到basic前一个进行递归排序
    quick_sort2(basic, tail); //从basic->next到tail前一个进行递归排序
}

int main(void)
{
    int i, len;
    node *head, *new, *p, *q;

    printf("请输入双向循环链表的长度: ");
    scanf("%d", &len);

    head = initList();
    head->data = len;

    printf("请输入元素：");
    for(int i = 0; i<len; i++)
    {
        new = initList();
        scanf("%d", &new->data);
        tail_insert(head, new);
    }

    printf("请选择排序方式，1.选择排序 2.冒泡排序 3.插入排序 4.快速排序: ");
    scanf("%d", &i);
    
    printf("排序前:\n");
    traverse(head);
    switch(i)
    {
        case 1:
            choose_sort(head);
            break;
        
        case 2:
            bubble_sort(head);
            break;

        case 3:
            insert_sort(head);
            break;

        case 4:
            quick_sort2(head, head);
            break;
    }

    printf("由小到大排序后:\n");
    traverse(head);

    return 0;
}

温馨提示：
        如果复制时发现有缩进报错，后者空格报错等问题，以VScode为例，可以按Ctrl+F，复制一个报错的空格，然后替换成一个手打的空格键，具体操作可以搜搜，可以看我的博客。


具体截图：以 12 34 78 56 23 99 34 12 45 76为例，其他朋友可以自己举

选择排序

 

冒泡排序

插入排序

快速排序

二、代码分析

        如果你认真看完上述的代码和注释，那么，我可以大概率保证你基本可以看懂了双向循环链表的排序，其实也不难，就是在关键步骤和控制条件。下面来仔细分析每个排序的关键步骤和控制条件。


冒泡排序

          思路：冒泡排序就是从首元结点开始，左右两两比较大小，以从小到大排序为例，如果比后面一个的节点大，就交换，然后继续往后比较，直到到达已经排好的元素为止。

        特点：每一轮冒泡排序结束后，总会把最大的节点放到最后面，不断的往前移，直到头结点，就结束了。

        注意的地方：单链表的交换，不同于数组的交换，单链表的交换后，以p和q为例，p在q的前面，如果p->data > q->data,就交换p和q节点，交换后p已经处于下一次待交换的位置，所以不需要在p = p->next了，否则会漏了一个没排，出错，需要特别注意!跟单链表的差不多！

        优化地方：1.设置flag，来标志链表中的元素是否已经是排好序的，因为这里做可以用一次循环判断出链表中的元素是否已经排好，而不用进行无用的多层循环。2.设置一个tail，来指明后面的节点是排好的，当遍历到tail时，就结束本轮循环，同时tail前移一个。

选择排序


        思路：选择排序就是每次从未排好的节点中，通过遍历比较大小的方法，选择出一个最小的（以从小到大排为例），然后插入到排好的后面，这样，每轮循环就可以选出一个最小的，直到全部插入完为止。

        特点：跟插入排序很像，但两者略有不同，选择排序先选出最小的，然后直接插入到排好元素的后面，而插入排序是直接选出一个节点，然后通过和排好的元素进行比较大小来插入到合适的位置。

        注意的地方：以从小到大排为例，采用尾插法应该是每次选取最小的，如果采用头插法应该是每次选取最大的。跟单链表的差不多！

        优化地方：如果这个节点本来就处于待插入地方，即当前最小的，就不需要交换了，直接进行下一轮。设置一个tail标志，之所以说有点像插入排序，就是体现在这里了。

插入排序


        思路：插入排序就是每次直接从未排好序的节点中拿一个出来，一般是下一个；然后在排好序的节点中通过遍历的方法来比较应该插入到的位置，直到插完为止。

        特点：直接选一个插入，不像选择排序那样，先选了，再插入。

        注意的地方：需要设置标志tail来指明已经排好的节点的界限，遍历查找插入位置时，遇到tail，说明待插入节点是已经排好的节点中最大的，不需要插入，同时tail要后移一个。跟单链表的差不多！

        优化地方：tail标志和直接插入。

快速排序


        思路：每次选中一个基准点，然后从基准点后面开始遍历，如果找到比基准点小节点（以从小到大排为例），就插入到基准点前面，直到链表的尾部，结束。这样每一次划分后，处于基准点前面的节点都比基准点小，处于基准点后面的节点都比基准点大。然后分别递归划分基准点前的节点和后的节点。

        特点：每次划分结束后能找到一个基准点，可以看成是中位数，然后递归。有点像二分查找，跟一颗二叉树差不多。

        注意的地方：第一次传参数时，传head(头节点）和NULL。而且需要严格控制退出条件，头结点为空，或者没有节点，或者只有一个节点时，不用排，直接返回。

        优化的地方：这里写了两种版本的，第一种，采用先定好基准点，后比较的方法，详情可以看我的博客里的单链表排序或者上面的讲解。

        另外一种版本，采用先比较，然后找出基准点，就是数组常用的，往中间靠的方法，一个head和tail,如果head<tail，tail就一直往前移，然后如果head<tail,head就一直往后移，直到head == tail是就是本次划分的基准点。因为是双向循环链表，有前指针，所以可以采用这种方法，单链表一般不采用这种方法，时间复杂度太高。

三、总结

        如果之前看过我博客里写的单链表排序，对于写双向循环链表排序，基本上直接搬过来就行，只需要修改一下结束条件单链表的为NULL,双向循环链表的为头结点head。

        虽然这么做很方便，但是体现不了双向循环链表的灵魂，单链表每次交换时，要额外寻找到其前驱节点，而双向循环链表不需要，直接就可以用，因为其本来就有前指针。所以我特意优化了某些地方，详情请对比两篇CSDN的代码注释。

        本期排序算法到这里，结束了，如果你觉得我写的不错，可不可以给我一个点赞，收藏，转发，评论等等，你们的支持，是我最大的动力！^_^

        下一期准备出C语言版的数组排序，冒泡排序，选择排序，插入排序，快速排序，堆排序，希尔排序等。记得关注我哦！^_^

Great Macro
关注
  • 18
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
双向排序--栈的应用
qq_15026719的博客
03-13 240
分析：如果单纯只用排序的思维来解这道题的话，无论什么排序，他的时间复杂的都不能完全满足题目要求。所以需要考虑优化操作步骤。就是尽量减少升序和降序的操作。 首先，当重复遇到降序操作时，那么只有这两次降序中的最大降序范围有效，比如对123456从1到3降序与1到4降序操作，两次操作后其实只有1到4有效，同样的道理两次连续的升序操作也只有范围大的有效。因此在遇到连续的0或者1时就需要将两次操作进行合并，例如 ...
双向排序--蓝桥杯
weixin_53443263的博客
03-31 1856
首先，测试数据很大，对每一个测试数据都sort一遍只能拿一点样例分，所以我们得想办法优化为nlogn。 寻找特性： 1.样例可简化为一段连续的0/1操作。 比如输入：0 6，0 8，0 7，1 3 ，1 4 可简化为0 8，1 3. 因为对于连续的0操作/1操作，里面有重复的步骤，比如我们先排0 6，再排0 8，会发现结果与只排0 8的结果一样，说明0 6操作是没有必要的，可以删除，所以0 6，0 8，0 7等价于只进行0 8。同理有1 3，1 4操作等价于1 3. 简而言之，对于连续的0或1操作，我们只.
【C语言】双链表的实现与冒泡排序
RedMaple
07-28 2844
【C语言】双链表的实现与冒泡排序 基于C语言，不做标题党，LInux下GCC通过编译，大致流程（底部附图，源码）： 新建双链表（节点数自定义），对节点data域用随机数种子进行随机赋值，并对该链表进行冒泡排序。 后续其他排序陆续更新...... 全局自定义函数如下： //链表新建函数 LinkList *creat_LinkList() //创建101个结点 void init...
双向循环链表的两种排序（2022最新 带 注释）
m0_57037805的博客
08-16 1410
内容：使用双向循环链表，实现自动插入数据并且对链表进行排序,带注释（2022最新）
双向链表实现双向冒泡排序
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-24 2284
n个记录存储在带头结点的双向链表中，利用双向冒泡排序对其进行升序排序。
链表的排序，包括选择，冒泡，插入，快速排序
10-29
选择排序，冒泡排序，插入排序，快速排序的链表实现和数组实现。 包括算法思想，指针描述，注意的要点等，还有代码注释。
c语言链表的排序算法-排序链表最快的算法是什么？.pdf
04-07
我们将比较不同的排序算法，包括合并排序和快速排序，并分析它们在链表中的性能。 首先，让我们讨论链表排序算法的挑战。链表的节点分布在内存中，可能会导致缓存未命中的情况，这会严重影响排序算法的性能。为了...
冒泡排序和选择排序_C语言_冒泡排序_选择排序_
09-29
链表版冒泡排序会涉及到创建临时节点来保存中间结果，以便在需要交换元素时保持链表的完整性。链表版选择排序则需要维护两个指针，一个指向当前未排序部分的最小元素，另一个用于更新已排序部分的末尾。 总的来说，...
基于C语言10个数据结构课程设计实例二叉树建立遍历冒泡排序快速排序等
最新发布
04-05
本课程设计实例集合了10个核心的数据结构问题，包括二叉树的建立、遍历，以及常用的排序算法——冒泡排序和快速排序。下面将详细解析这些知识点。 一、数据结构 数据结构是编程中用于组织和管理大量数据的方法。...
double-link-list.rar_double link list_双向链表排序
09-19
双向链表的排序可以使用多种算法，例如插入排序、归并排序或快速排序。这里以插入排序为例，其基本思想是将未排序的节点逐个插入到已排序的链表中： ```cpp void sortList(Node* head) { if (head == nullptr || ...
【C语言】双向冒泡排序算法
weixin_55582076的博客
09-03 773
以下算法是双向冒泡排序算法，基于冒泡排序的变种，个人学习用，仅供参考。
双向链表的双向冒泡排序
tokosuki的博客
06-01 324
【代码】双向链表的双向冒泡排序。
数据结构（C/C++）双向链表双向冒泡排序
qq_16674623的博客
12-10 1759
双向链表做冒泡排序
【数据结构与算法】有n个记录存储在带头结点的双向链表中，现用双向冒泡排序法对其按上升序进行排序
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
07-07 6995
有n个记录存储在带头结点的双向链表中，现用双向冒泡排序法对其按上升序进行排序，请写出这种排序的算法。（注：双向冒泡排序即相邻两趟排序向相反方向冒泡）
[C语言]双向链表的快速排序
CRAJA的blog
03-13 3970
之前一直想用双向链表来快排,想像数组快排一样给第一个数组下标(第一个有值节点的指针)和最后一个数组下标(最后一个有值节点指针),结果运行时经常有问题,程序有时会出错,于是纸上演算了几次发现会访问到未知的内存. 因为当low和high在最左侧或者最右侧相同时,再经过一次调用时 Box_Qsort(i,low->prev); Box_Qsort(low->next,j); 可以发现因为最后一个有值节点的next为NULL,当此时low为NULL, Box *key = (Box *)malloc
【蓝桥杯】双向排序
weixin_51755941的博客
03-08 4158
解题： 操作类型和参数： 操作类型：决定是升序还是降序 参数：从下标多少开始升序或者降序 如果是降序的话： 从数组第一个元素到数组第参数个元素的位置进行降序 如果是升序的话： 从数组中第参数个元素到数组最后一位元素进行升序 代码如下： package Example02; import java.util.Arrays; import java.util.Scanner; public class 双向......
数据结构--排序循环双链表
吴声子夜歌的博客
01-15 1188
排序循环双链表 实现 package pers.zhang.linearList; /** * @author zhang * @date 2020/1/15 - 15:16 * * 按升序排序的循环双链表类，继承循环双链表类，E必须实现Comparable<T>接口，支持对象可比较大小 */ public class SortedDoublyLinkedList<...
双向链表的排序
青青的专栏--C/C++ OOA/D Design Pattern
07-28 1773
以前写过双向链表交换任意结点的程序,后来写了个双向链表排序的程序,没用边输入边排序的思想,是输入完毕后我按照选择法排序的思想对链表的结点进行交换.是地址交换.#include typedef struct Link/*双向链表结构体*/{ int data; struct Link *lift; struct Link *right;}linkx,*linky;linky InIT();/*建立双
排序算法之快速排序
axwh43098的博客
05-22 296
基本概念 快速排序是非常流行、应用非常广泛的排序算法，而且实现简单，适用于各种不同的输入数据，在一般应用中比其他排序算法都要快很多。快速排序是基于分治思想的原地排序的排序算法，将长度为N的数组排序所需时间和NlgN成正比，而且内循环比大多数排序算法都要短小和简单，因此一般情况比其他排序算法效率高。它的缺点是非常脆弱，某些情况可能导致它的性能达到平方级别，...
双向循环链表快速排序
10-20
双向循环链表快速排序是一种基于双向循环链表的排序算法，它的时间复杂度为O(nlogn)。下面是具体的步骤： 1. 选取一个基准元素pivot，将链表分为两个部分，一部分是小于等于pivot的元素，另一部分是大于pivot的元素。 2. 对于两个部分分别进行递归排序。 3. 将两个部分合并起来。 具体实现时，可以先将链表转化为数组，然后对数组进行快速排序，最后再将数组转化为链表。也可以直接在链表上进行排序，具体实现可以参考以下步骤： 1. 选取一个基准元素pivot，将链表分为两个部分，一部分是小于等于pivot的元素，另一部分是大于pivot的元素。 2. 对于两个部分分别进行递归排序。 3. 将两个部分合并起来。 4. 合并时，需要注意将两个部分的头尾相连，形成一个新的双向循环链表。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值