单向链表排序

  1 #include <stdio.h>
  2 #include <malloc.h>
  3 
  4 /* 排序状态取值表 */
  5 typedef enum
  6 {
  7     SORT_OK,    /* 排序成功标志 */
  8     SORT_ERR    /* 排序失败标志 */
  9 }SORTSTATE;        
 10 
 11 /* 接点结构体 */
 12 struct node{
 13     struct node * pnext;
 14     unsigned int value;
 15 };
 16 
 17 typedef struct node Node;
 18 
 19 SORTSTATE sort(Node * * chainhead);
 20 
 21 /** @函数功能：测试单向链表排序功能
 22   * @输入参数：无
 23   * @输出参数：无用
 24   */
 25 int main(void)
 26 {
 27     Node * head,* p;
 28     SORTSTATE status;
 29 
 30     /* 构建单向链表 */
 31     p = (Node *)malloc(sizeof(Node));
 32     head = p;                                    /* 保存链表头部 */
 33     p->value = 5;
 34     p->pnext = (Node *)malloc(sizeof(Node));
 35 
 36     p = p->pnext;
 37     p->value = 97;
 38     p->pnext = (Node *)malloc(sizeof(Node));
 39 
 40     p = p->pnext;
 41     p->value = 7;
 42     p->pnext = (Node *)malloc(sizeof(Node));
 43 
 44     p = p->pnext;
 45     p->value = 65;
 46     p->pnext = (Node *)malloc(sizeof(Node));
 47 
 48     p = p->pnext;
 49     p->value = 12;
 50     p->pnext = (Node *)malloc(sizeof(Node)); 
 51 
 52     p = p->pnext;
 53     p->value = 1;
 54     p->pnext = NULL;                            /* 链尾初始化为空 */
 55 
 56     /* 打印链表的内容 */
 57     p = head;
 58     while(p != NULL){
 59         printf("%4d",p->value);
 60         p = p->pnext;
 61     }
 62     printf("\n");
 63 
 64     /* 链表排序 */
 65     status = sort(&head);
 66     if(status == SORT_ERR){
 67         printf("Chain is wrong!\n");
 68     }
 69     
 70     /* 打印链表的内容 */
 71     p = head;
 72     while(p != NULL){
 73         printf("%4d",p->value);
 74         p = p->pnext;
 75     }
 76     printf("\n");
 77 
 78     return 0;
 79 }
 80 
 81 
 82 /** @函数功能：单向链表排序
 83   * @输入参数：指向链表头部的指针
 84   *        注意：指向指针的指针可以修改指针的指向
 85   * @输出参数：SORTSTATE 排序成功与否状态
 86   */
 87 SORTSTATE sort(Node * * chainhead)
 88 {
 89     Node * head,                                    /* 当前比较接点的上一个接点 */
 90          * first,                                    /* 当前比较接点 */
 91          * second,                                    /* 当前参与比较的另一个接点 */
 92          * end;                                        /* 当前比较接点的终点
 93                                                      * 终点意味着从终点开始往后的
 94                                                      * 链表排序已经确定，只需要将
 95                                                      * 终点前的所有接点按照冒泡法
 96                                                      * 排序，排序就将完成。
 97                                                      */
 98 
 99     if(*chainhead == NULL)                            /* 链表是否为空 */
100         return SORT_ERR;
101     if((*chainhead)->pnext == NULL)                    /* 链表是否就只有一个接点 */
102         return SORT_OK;
103 
104     end = NULL;                                        /* 第一轮冒泡排序的终点接点值为NULL */
105 
106     /* 冒泡法排序,可能有很多轮次 */
107     while(end != (*chainhead)->pnext){                /* 如果排序的终点等于接点的第二个地址，
108                                                      * 也就是说从第二个接点开始所有的接点
109                                                      * 都已经按照从小到大的顺序确定了位置。
110                                                      * 显然，剩下的唯一一个“第一接点”位置
111                                                      * 也就确定了。所有排序全部完成。
112                                                      */
113 
114         /* 首先比较位于头部的两个接点，由于位于头部，
115          * 与其他接点不一样,需要放在循环外边，单独处理。
116          */
117         first =   *chainhead;                        /* 第一个比较接点是链表头部指向的接点 */
118         second = first->pnext;                        /* 第二个比较接点是紧邻的第二个接点 */
119         
120         /* 是否需要更改链表的连接顺序 */
121         if(first->value > second->value){            
122             *chainhead = second;                    /* 更改链表头部的指向 */    
123             /* 重新连接链表，就相当于对链表排序 */
124             first->pnext = second->pnext;            
125             second->pnext = first;            
126         }
127 
128         /* 移动比较接点到下两个接点 */
129         head = *chainhead;                            /* 当前比较接点的上一个接点则是头部接点 */
130         first = head->pnext;                        /* 当前比较接点 */
131         second = first->pnext;                        /* 当前参与比较的另一个接点 */
132         
133         while(second != end)                        /* 此轮的比较是否结束 */
134         {
135             /* 是否需要更改链表的连接顺序 */
136             if(first->value > second->value){    
137                 /* 重新连接链表，就相当于对链表排序 */
138                 head->pnext = second;    
139                 first->pnext = second->pnext;
140                 second->pnext = first;
141                 
142             }
143             /* 移动比较接点到下两个接点 */
144             head = head->pnext;
145             first = head->pnext;
146             second = first->pnext;
147         }
148 
149         end = first;                                /* 一轮排序完成，结束接点位置上移一个 */
150     }
151 
152     return SORT_OK;                                    /* 排序成功 */