单向链表排序

最新推荐文章于 2022-06-15 00:16:36 发布

夏華

最新推荐文章于 2022-06-15 00:16:36 发布

阅读量1.4k

点赞数

一、冒泡排序简述

1、概念

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
　　它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

2、实例分析

以数组为例进行说明：
　　数组a[4] = {4,3,2,1}

从前向后依次比较两个元素的大小，如果顺序错误就交换它们。经过这样一轮，最大的元素就被交换到了数组的顶端，好像是最大的元素“浮”上去一样。经过这样一轮，最后的一个元素的已经确定。a[4] = {3,2,1,4}

再次重复上边的操作，只不过因为上一轮最后一个元素已经确定，所以这一次比较的终点（以此为界，不能超过此界）就是上一轮的最后一个元素。也就是，第二轮的比较中，数组最后一个元素没有参与比较。第二轮比较中的最后一个元素是倒数第二个元素。经过这样一轮比较，倒数第二个元素也被确定。a[4] = {2,1,3,4}

重复这样的操作，直到数组的第二个元素被确定。因为除了第一个元素外，所有的元素都被锁定，所以第一个元素实际上也被确定。到此为止，排序完成。a[4] = {1,2,3,4}

3、冒泡排序的关键
<1> 每经过一轮的排序，一个最大的元素被“浮”到对应的位置。随之，下一次比较的终点也需要向前移一个元素。
<2> 当正数第二个元素被确定的时候，冒泡排序完成。

二、冒泡法应用于单向链表排序

1、实例展示
① 初始链表

在这里插入图片描述
② 第一轮排序

③ 第二轮排序

④ 第三轮排序

算法流程图

#include <stdio.h>
#include <malloc.h>

/* 排序状态取值表 */
typedef enum
{
    SORT_OK,    /* 排序成功标志 */
    SORT_ERR    /* 排序失败标志 */
}SORTSTATE;        

/* 接点结构体 */
struct node{
    struct node * pnext;
    unsigned int value;
};

typedef struct node Node;

SORTSTATE sort(Node * * chainhead);

/** @函数功能：测试单向链表排序功能
  * @输入参数：无
  * @输出参数：无用
  */
int main(void)
{
    Node * head,* p;
    SORTSTATE status;

    /* 构建单向链表 */
    p = (Node *)malloc(sizeof(Node));
    head = p;                                    /* 保存链表头部 */
    p->value = 5;
    p->pnext = (Node *)malloc(sizeof(Node));

    p = p->pnext;
    p->value = 97;
    p->pnext = (Node *)malloc(sizeof(Node));

    p = p->pnext;
    p->value = 7;
    p->pnext = (Node *)malloc(sizeof(Node));

    p = p->pnext;
    p->value = 65;
    p->pnext = (Node *)malloc(sizeof(Node));

    p = p->pnext;
    p->value = 12;
    p->pnext = (Node *)malloc(sizeof(Node)); 

    p = p->pnext;
    p->value = 1;
    p->pnext = NULL;                            /* 链尾初始化为空 */

    /* 打印链表的内容 */
    p = head;
    while(p != NULL){
        printf("%4d",p->value);
        p = p->pnext;
    }
    printf("\n");

    /* 链表排序 */
    status = sort(&head);
    if(status == SORT_ERR){
        printf("Chain is wrong!\n");
    }
    
    /* 打印链表的内容 */
    p = head;
    while(p != NULL){
        printf("%4d",p->value);
        p = p->pnext;
    }
    printf("\n");

    return 0;
}


/** @函数功能：单向链表排序
  * @输入参数：指向链表头部的指针
  *        注意：指向指针的指针可以修改指针的指向
  * @输出参数：SORTSTATE 排序成功与否状态
  */
SORTSTATE sort(Node * * chainhead)
{
    Node * head,                                    /* 当前比较接点的上一个接点 */
         * first,                                    /* 当前比较接点 */
         * second,                                    /* 当前参与比较的另一个接点 */
         * end;                                        /* 当前比较接点的终点
                                                     * 终点意味着从终点开始往后的
                                                     * 链表排序已经确定，只需要将
                                                     * 终点前的所有接点按照冒泡法
                                                     * 排序，排序就将完成。
                                                     */

    if(*chainhead == NULL)                            /* 链表是否为空 */
        return SORT_ERR;
    if((*chainhead)->pnext == NULL)                    /* 链表是否就只有一个接点 */
        return SORT_OK;

    end = NULL;                                        /* 第一轮冒泡排序的终点接点值为NULL */

    /* 冒泡法排序,可能有很多轮次 */
    while(end != (*chainhead)->pnext){                /* 如果排序的终点等于接点的第二个地址，
                                                     * 也就是说从第二个接点开始所有的接点
                                                     * 都已经按照从小到大的顺序确定了位置。
                                                     * 显然，剩下的唯一一个“第一接点”位置
                                                     * 也就确定了。所有排序全部完成。
                                                     */

        /* 首先比较位于头部的两个接点，由于位于头部，
         * 与其他接点不一样,需要放在循环外边，单独处理。
         */
        first =   *chainhead;                        /* 第一个比较接点是链表头部指向的接点 */
        second = first->pnext;                        /* 第二个比较接点是紧邻的第二个接点 */
        
        /* 是否需要更改链表的连接顺序 */
        if(first->value > second->value){            
            *chainhead = second;                    /* 更改链表头部的指向 */    
            /* 重新连接链表，就相当于对链表排序 */
            first->pnext = second->pnext;            
            second->pnext = first;            
        }

        /* 移动比较接点到下两个接点 */
        head = *chainhead;                            /* 当前比较接点的上一个接点则是头部接点 */
        first = head->pnext;                        /* 当前比较接点 */
        second = first->pnext;                        /* 当前参与比较的另一个接点 */
        
        while(second != end)                        /* 此轮的比较是否结束 */
        {
            /* 是否需要更改链表的连接顺序 */
            if(first->value > second->value){    
                /* 重新连接链表，就相当于对链表排序 */
                head->pnext = second;    
                first->pnext = second->pnext;
                second->pnext = first;
                
            }
            /* 移动比较接点到下两个接点 */
            head = head->pnext;
            first = head->pnext;
            second = first->pnext;
        }

        end = first;                                /* 一轮排序完成，结束接点位置上移一个 */
    }

    return SORT_OK;                                    /* 排序成功 */