码迷,mamicode.com
首页 > 编程语言 > 详细

将单链表排序的两种方法

时间:2017-04-26 20:25:58      阅读:280      评论:0      收藏:0      [点我收藏+]

标签:short   ror   rman   return   避免   put   data   ora   blank   

对单链表排序,通常有两种方法。(PS:考察一个程序员的C语言编程功底,通常看他是否能娴熟的操作链表就知道了。

  • 方法1:将每一个结点保存到额外的数组中,对数组进行排序,然后根据有序的数组重新构建链表。
  • 方法2:直接对链表进行插入排序,但是实现起来比较复杂一些。

显然,方法1最为简单,因为将链式存储L先转化为顺序存储a[],对顺序存储a[]排序,就避免了较为复杂的链接指针操作。一旦对顺序存储a[]排好序后,根据a[]重新构建一个链表是易如反掌的事情。

1. 单链表的定义如下

typedef struct list_s {
        int data;
        struct list_s *next;
} list_t;

2. 方法1

 1 /*
 2  * Insert a[n] before a[m]
 3  *                                                .-----------.
 4  *                                                |           |
 5  * o Input : a[m-1], a[m], a[m+1], ..., a[n-1], a[n], a[n+1]  |
 6  *                        \     \             \               |
 7  * o Output: a[m-1], a[n], a[m], a[m+1], ..., a[n-1], a[n+1]  |
 8  *                       \____________________________________/
 9  */
10 static void
11 insert(list_t *a[], int m, int n)
12 {
13         list_t *t = a[n];
14         for (int i = n; i > m; i--)
15                 a[i] = a[i-1];
16         a[m] = t;
17 }
18 
19 /*
20  * Straight Insertion Sort (sisort in short)
21  *
22  * NOTES:
23  *      1. a[i .. n-1] is not sorted and
24  *         a[0 .. i-1] is sorted
25  *      2. walk a[0 .. i-1], if a[i] < a[j], insert a[i] before a[j]
26  */
27 static void
28 sisort(list_t *a[], size_t n)
29 {
30         for (int i = 1; i < n; i++) {
31                 for (int j = 0; j < i; j++) {
32                         if (a[i]->data < a[j]->data) {
33                                 insert(a, j, i);
34                                 break;
35                         }
36                 }
37         }
38 }
39 
40 static void
41 list_sort(list_t **head)
42 {
43         if (head == NULL || *head == NULL)
44                 return;
45 
46         /* get total number of nodes in the single linked list */
47         int len = 0;
48         for (list_t *p = *head; p != NULL; p = p->next)
49                 len++;
50 
51         /* malloc aux[] */
52         list_t **aux = (list_t **)malloc(sizeof (list_t *) * len);
53         if (aux == NULL) /* error */
54                 return;
55 
56         /* save addr of per node to aux[] */
57         int k = 0;
58         for (list_t *p = *head; p != NULL; p = p->next)
59                 aux[k++] = p;
60 
61         /* sort aux[] via straight insertion sorting algorithm */
62         sisort(aux, len);
63 
64         /* rebuild the single linked list by walking aux[] */
65         *head = aux[0];
66         for (int i = 0; i < len - 1; i++)
67                 aux[i]->next = aux[i+1];
68         aux[len-1]->next = NULL;
69 
70         free(aux);
71 }

3. 方法2

 1 static void
 2 list_insert(list_t **head, list_t *node)
 3 {
 4         if (*head == NULL) {
 5                 *head = node;
 6                 return;
 7         }
 8 
 9         /* get both prev and next of the node to insert */
10         list_t *node_prev = *head;
11         list_t *node_next = NULL;
12         for (list_t *p = *head; p != NULL; p = p->next) {
13                 if (p->data < node->data) {
14                         node_prev = p;
15                         continue;
16                 }
17 
18                 node_next = p;
19                 break;
20         }
21 
22         if (node_next == NULL) { /* append node to the tail */
23                 node_prev->next = node;
24         } else {
25                 if (node_next == node_prev) { /* == *head */
26                         node->next = *head;
27                         *head = node;
28                         return;
29                 }
30 
31                 /* node_prev -> node -> node_next */
32                 node_prev->next = node;
33                 node->next = node_next;
34         }
35 }
36 
37 static void
38 list_sort(list_t **head)
39 {
40         if (*head == NULL)
41                 return;
42 
43         list_t *headp = *head; /* copy *head to headp before snip headp->next */
44         list_t *p = headp->next; /* init p (move forward) before cut-off */
45         headp->next = NULL;      /* now cut off headp->next */
46 
47         while (p != NULL) {
48                 list_t *this = p;  /* copy p to this before snip this->next */
49                 p = p->next;       /* move p forward before cut-off */
50                 this->next = NULL; /* now cut off this->next */
51                 list_insert(&headp, this); /* insert this node to list headp */
52         }
53 
54         *head = headp; /* always save headp back even if headp == *head */
55 }

4. 完整的C代码实现(戳这里

o sort.c

  1 /*
  2  * Single Linked List Sorting
  3  *
  4  *      1. convert a[] to a single linked list L
  5  *         e.g. int a[] = {9, 8, 7, 7}
  6  *         ==>        L = 9->8->7->7->NULL
  7  *      2. sort list L via straight insertion sorting
  8  *         ==>        L = 7->7->8->9->NULL
  9  *      3. convert list L back to a[]
 10  *         ==>      a[] = {7, 7, 8, 9}
 11  *
 12  * Note there are two solutions,
 13  *      (a) Use aux[] to save addr of per node in list L, then sort aux[] via
 14  *          straight insertion sorting algorithm, and rebuild list L by walking
 15  *          sorted aux[]
 16  *      (b) Don‘t use aux[] but directly sort the single liked list L
 17  *
 18  *      To implement the two solutions above, (a) is very easy and (b) is a bit
 19  *      difficult. Please also keep in mind that performance of (b) is good.
 20  */
 21 
 22 #include <stdio.h>
 23 #include <stdlib.h>
 24 #include <string.h>
 25 
 26 typedef enum bool_s {false, true} bool_t;
 27 
 28 bool_t g_isint = true;
 29 
 30 typedef struct list_s {
 31         int data;
 32         struct list_s *next;
 33 } list_t;
 34 
 35 #ifdef _USE_AUX /* solution (a) */
 36 static void
 37 list_init(list_t **head, list_t *node)
 38 {
 39         static list_t *tail = NULL;
 40 
 41         if (*head == NULL) {
 42                 *head = node;
 43                 tail = node;
 44                 return;
 45         }
 46 
 47         tail->next = node;
 48         tail = node;
 49 }
 50 #else
 51 static void
 52 list_init(list_t **head, list_t *node)
 53 {
 54         if (*head == NULL) {
 55                 *head = node;
 56                 return;
 57         }
 58 
 59         list_t *q = *head;
 60         for (list_t *p = *head; p != NULL; p = p->next)
 61                 q = p;
 62         q->next = node;
 63 }
 64 #endif
 65 
 66 static void
 67 list_show(list_t *head)
 68 {
 69         if (head == NULL)
 70                 return;
 71 
 72         for (list_t *p = head; p != NULL; p = p->next)
 73                 printf("%d ", p->data);
 74         printf("\n");
 75 }
 76 
 77 static void
 78 list_fini(list_t *head)
 79 {
 80         list_t *p = head;
 81         while (p != NULL) {
 82                 list_t *q = p;
 83                 p = p->next;
 84                 free(q);
 85         }
 86 }
 87 
 88 #ifdef _USE_AUX /* solution (a) */
 89 /*
 90  * Insert a[n] before a[m]
 91  *                                                .-----------.
 92  *                                                |           |
 93  * o Input : a[m-1], a[m], a[m+1], ..., a[n-1], a[n], a[n+1]  |
 94  *                        \     \             \               |
 95  * o Output: a[m-1], a[n], a[m], a[m+1], ..., a[n-1], a[n+1]  |
 96  *                       \____________________________________/
 97  */
 98 static void
 99 insert(list_t *a[], int m, int n)
100 {
101         list_t *t = a[n];
102         for (int i = n; i > m; i--)
103                 a[i] = a[i-1];
104         a[m] = t;
105 }
106 
107 /*
108  * Straight Insertion Sort (sisort in short)
109  *
110  * NOTES:
111  *      1. a[i .. n-1] is not sorted and
112  *         a[0 .. i-1] is sorted
113  *      2. walk a[0 .. i-1], if a[i] < a[j], insert a[i] before a[j]
114  */
115 static void
116 sisort(list_t *a[], size_t n)
117 {
118         for (int i = 1; i < n; i++) {
119                 for (int j = 0; j < i; j++) {
120                         if (a[i]->data < a[j]->data) {
121                                 insert(a, j, i);
122                                 break;
123                         }
124                 }
125         }
126 }
127 
128 static void
129 list_sort(list_t **head)
130 {
131         if (head == NULL || *head == NULL)
132                 return;
133 
134         /* get total number of nodes in the single linked list */
135         int len = 0;
136         for (list_t *p = *head; p != NULL; p = p->next)
137                 len++;
138 
139         /* malloc aux[] */
140         list_t **aux = (list_t **)malloc(sizeof (list_t *) * len);
141         if (aux == NULL) /* error */
142                 return;
143 
144         /* save addr of per node to aux[] */
145         int k = 0;
146         for (list_t *p = *head; p != NULL; p = p->next)
147                 aux[k++] = p;
148 
149         /* sort aux[] via straight insertion sorting algorithm */
150         sisort(aux, len);
151 
152         /* rebuild the single linked list by walking aux[] */
153         *head = aux[0];
154         for (int i = 0; i < len - 1; i++)
155                 aux[i]->next = aux[i+1];
156         aux[len-1]->next = NULL;
157 
158         free(aux);
159 }
160 #else
161 static void
162 list_insert(list_t **head, list_t *node)
163 {
164         if (*head == NULL) {
165                 *head = node;
166                 return;
167         }
168 
169         /* get both prev and next of the node to insert */
170         list_t *node_prev = *head;
171         list_t *node_next = NULL;
172         for (list_t *p = *head; p != NULL; p = p->next) {
173                 if (p->data < node->data) {
174                         node_prev = p;
175                         continue;
176                 }
177 
178                 node_next = p;
179                 break;
180         }
181 
182         if (node_next == NULL) { /* append node to the tail */
183                 node_prev->next = node;
184         } else {
185                 if (node_next == node_prev) { /* == *head */
186                         node->next = *head;
187                         *head = node;
188                         return;
189                 }
190 
191                 /* node_prev -> node -> node_next */
192                 node_prev->next = node;
193                 node->next = node_next;
194         }
195 }
196 
197 static void
198 list_sort(list_t **head)
199 {
200         if (*head == NULL)
201                 return;
202 
203         list_t *headp = *head; /* copy *head to headp before snip headp->next */
204         list_t *p = headp->next; /* init p (move forward) before cut-off */
205         headp->next = NULL;      /* now cut off headp->next */
206 
207         while (p != NULL) {
208                 list_t *this = p;  /* copy p to this before snip this->next */
209                 p = p->next;       /* move p forward before cut-off */
210                 this->next = NULL; /* now cut off this->next */
211                 list_insert(&headp, this); /* insert this node to list headp */
212         }
213 
214         *head = headp; /* always save headp back even if headp == *head */
215 }
216 #endif
217 
218 static void
219 show(int a[], size_t n)
220 {
221         if (g_isint) {
222                 for (int i = 0; i < n; i++)
223                         printf("%-2d ", a[i]);
224         } else {
225                 for (int i = 0; i < n; i++)
226                         printf("%-2c ", a[i]);
227         }
228         printf("\n");
229 }
230 
231 static void
232 a2l_init(list_t **head, int a[], size_t n)
233 {
234         for (int i = 0; i < n; i++) {
235                 list_t *nodep = NULL;
236                 nodep = (list_t *)malloc(sizeof (list_t));
237                 if (nodep == NULL) /* error: failed to malloc */
238                         return;
239 
240                 nodep->data = a[i];
241                 nodep->next = NULL;
242 
243                 list_init(head, nodep);
244 
245                 printf("Append a[%x]=%d:\t", i, nodep->data); list_show(*head);
246         }
247 
248 }
249 
250 static void
251 a2l_fini(list_t *head, int a[], size_t n)
252 {
253         if (head == NULL)
254                 return;
255 
256         int k = 0;
257         for (list_t *p = head; p != NULL; p = p->next) {
258                 a[k++] = p->data;
259 
260                 if (k >= n)
261                         break;
262         }
263 
264         list_fini(head);
265 }
266 
267 int
268 main(int argc, char *argv[])
269 {
270         if (argc < 2) {
271                 fprintf(stderr, "Usage: %s <C1> [C2] ...\n", argv[0]);
272                 return -1;
273         }
274 
275         argc--;
276         argv++;
277 
278         int n = argc;
279         int *a = (int *)malloc(sizeof(int) * n);
280 #define VALIDATE(p) do { if (p == NULL) return -1; } while (0)
281         VALIDATE(a);
282 
283         char *s = getenv("ISINT");
284         if (s != NULL && strncmp(s, "true", 4) == 0)
285                 g_isint = true;
286         else if (s != NULL && strncmp(s, "false", 4) == 0)
287                 g_isint = false;
288 
289         if (g_isint) {
290                 for (int i = 0; i < n; i++)
291                         *(a+i) = atoi(argv[i]);
292         } else {
293                 for (int i = 0; i < n; i++)
294                         *(a+i) = argv[i][0];
295         }
296 
297         printf("                ");
298         for (int i = 0; i < n; i++)
299                 printf("%-2x ", i);
300         printf("\n");
301 
302         printf("Before sorting: "); show(a, n);
303         list_t *head = NULL;
304         a2l_init(&head, a, n);
305         list_sort(&head);
306         a2l_fini(head, a, n);
307         printf("After  sorting: "); show(a, n);
308 
309 #define FREE(p) do { free(p); p = NULL; } while (0)
310         FREE(a);
311         return 0;
312 }

o 编译并测试

$ gcc -g -Wall -m32 -std=c99 -D_USE_AUX -o sort sort.c
$ ./sort 9 8 7 6 5 4 3 2 1 0 10 1
                0  1  2  3  4  5  6  7  8  9  a  b
Before sorting: 9  8  7  6  5  4  3  2  1  0  10 1
Append a[0]=9:  9
Append a[1]=8:  9 8
Append a[2]=7:  9 8 7
Append a[3]=6:  9 8 7 6
Append a[4]=5:  9 8 7 6 5
Append a[5]=4:  9 8 7 6 5 4
Append a[6]=3:  9 8 7 6 5 4 3
Append a[7]=2:  9 8 7 6 5 4 3 2
Append a[8]=1:  9 8 7 6 5 4 3 2 1
Append a[9]=0:  9 8 7 6 5 4 3 2 1 0
Append a[a]=10: 9 8 7 6 5 4 3 2 1 0 10
Append a[b]=1:  9 8 7 6 5 4 3 2 1 0 10 1
After  sorting: 0  1  1  2  3  4  5  6  7  8  9  10

$ gcc -g -Wall -m32 -std=c99 -o sort sort.c
$ ./sort 9 8 7 6 5 4 3 2 1 0 10 1
                0  1  2  3  4  5  6  7  8  9  a  b
Before sorting: 9  8  7  6  5  4  3  2  1  0  10 1
Append a[0]=9:  9
Append a[1]=8:  9 8
Append a[2]=7:  9 8 7
Append a[3]=6:  9 8 7 6
Append a[4]=5:  9 8 7 6 5
Append a[5]=4:  9 8 7 6 5 4
Append a[6]=3:  9 8 7 6 5 4 3
Append a[7]=2:  9 8 7 6 5 4 3 2
Append a[8]=1:  9 8 7 6 5 4 3 2 1
Append a[9]=0:  9 8 7 6 5 4 3 2 1 0
Append a[a]=10: 9 8 7 6 5 4 3 2 1 0 10
Append a[b]=1:  9 8 7 6 5 4 3 2 1 0 10 1
After  sorting: 0  1  1  2  3  4  5  6  7  8  9  10

 

将单链表排序的两种方法

标签:short   ror   rman   return   避免   put   data   ora   blank   

原文地址:http://www.cnblogs.com/idorax/p/6763490.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!