[已解决]C中输入任意多个数，排序

套你猴子（甲鱼

    任意多是指事先不知道多少个数，在输入时想什么时候停止就停止，除了定义一个足够大的数组外，还有没有别的方法？
不需要程序问我想输入多少个数（。。）

最佳答案

月排行榜 / 总排行榜

Croper

2019-5-8 21:31:55

你这是两个问题：
第一：如何判断一串数字输入完毕的问题
  1）确定输入的数字间以什么分割：最好空格或tab分割，这样可以使用scanf直接读取，其他的分割方式，如','分割，需要进行特殊处理
  2）确定以什么标志输入结束，以及如何判断输入结束：如果以回车结束，需要用getchar判断'\n'符号，同时需要考虑空格接回车等不太规范的输入

第二、如何储存这些数字：
   1) 申请一个足够大的数组，推荐
   2）申请一个较小的数组，不够再使用realloc扩大容量，如果数据量非常大的话可考虑
   3）链表，不推荐，排序的效率将会大大降低

反正思路就这样，怎么实现就看你了

跳转到最佳答案楼层

套你猴子（甲鱼

思路，用回车符判断输入结束就可以了

Croper

你这是两个问题：
第一：如何判断一串数字输入完毕的问题
  1）确定输入的数字间以什么分割：最好空格或tab分割，这样可以使用scanf直接读取，其他的分割方式，如','分割，需要进行特殊处理
  2）确定以什么标志输入结束，以及如何判断输入结束：如果以回车结束，需要用getchar判断'\n'符号，同时需要考虑空格接回车等不太规范的输入

第二、如何储存这些数字：
   1) 申请一个足够大的数组，推荐
   2）申请一个较小的数组，不够再使用realloc扩大容量，如果数据量非常大的话可考虑
   3）链表，不推荐，排序的效率将会大大降低

反正思路就这样，怎么实现就看你了

套你猴子（甲鱼

Croper 发表于 2019-5-8 21:31
你这是两个问题：
第一：如何判断一串数字输入完毕的问题
  1）确定输入的数字间以什么分割：最好空格或t ...

嗯，谢谢你的详细的补充。

人造人

Croper 发表于 2019-5-8 21:31
你这是两个问题：
第一：如何判断一串数字输入完毕的问题
  1）确定输入的数字间以什么分割：最好空格或t ...

我认为链表的排序效率高过数组
链表只需要修改指针的指向就行了，数组需要移动大量数据元素，如果这个数据元素比较大的话，那效率更是不容乐观

Croper

人造人 发表于 2019-5-8 21:56
我认为链表的排序效率高过数组
链表只需要修改指针的指向就行了，数组需要移动大量数据元素，如果这个数 ...

嗯。。。同样的方法两者代码写出来都是同样的数量级(O[nlogn]或O[n^2]，视排序方法不同),但是链表本神的访问就比数组要慢得多
（忘了在哪儿看的了，即使是a[1](链表就是head->next)这种访问，链表都要比数组慢一个数量级),
链表的优势在插入，和删除中间元素，但主流的排序方法除了插入排序，似乎涉及不到这一点，
所以除非插入排序，链表完全没有优势吧。

人造人

Croper 发表于 2019-5-8 22:50
嗯。。。同样的方法两者代码写出来都是同样的数量级(O[nlogn]或O[n^2]，视排序方法不同),但是链表本神 ...

我又花时间研究了一下这部分的内容，我发现了我之前犯的错误，但是我依然没有找到 数组的排序效率高过链表的排序效率的方法

“我认为链表的排序效率高过数组
链表只需要修改指针的指向就行了，数组需要移动大量数据元素，如果这个数据元素比较大的话，那效率更是不容乐观”


数组需要移动大量数据元素
好的排序算法可以避免移动大量数据元素，但是对于数组，移动数据元素是不可避免的，而链表只需要修改指针


“我认为链表的排序效率高过数组
链表只需要修改指针的指向就行了，而数组需要移动数据元素，如果这个数据元素比较大的话，那效率更是不容乐观”

下面用代码说话

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. typedef struct
   
6. {
   
7.         size_t id;
   
8.         char name[64];
   
9. } user_info_t;
   
10. 
    
11. void swap(user_info_t *a, user_info_t *b)
    
12. {
    
13.         user_info_t temp = *a;
    
14.         *a = *b;
    
15.         *b = temp;
    
16. }
    
17. 
    
18. // 按id排序
    
19. void sort(user_info_t info[], size_t size)
    
20. {
    
21.         for(size_t i = 0; i < size; ++i)
    
22.         {
    
23.                 for(size_t j = i + 1; j < size; ++j)
    
24.                 {
    
25.                         if(info[i].id > info[j].id)
    
26.                                 swap(&info[i], &info[j]);
    
27.                 }
    
28.         }
    
29. }
    
30. 
    
31. int main(void)
    
32. {
    
33.         printf("user_info_t size: %ld\n", sizeof(user_info_t));
    
34. 
    
35.         user_info_t info[1024];
    
36.         for(size_t i = 0; i < 1024; ++i)
    
37.         {
    
38.                 info[i].id = 1024 - i;
    
39.         }
    
40. 
    
41.         sort(info, 1024);
    
42.         for(size_t i = 0; i < 1024; ++i)
    
43.                 printf("%ld ", info[i].id);
    
44.         printf("\n");
    
45.         return 0;
    
46. }

复制代码

数组版本用时33ms

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. typedef struct
   
6. {
   
7.         size_t id;
   
8.         char name[64];
   
9. } user_info_t;
   
10. 
    
11. typedef user_info_t elem_type;
    
12. 
    
13. typedef struct node_tag
    
14. {
    
15.         elem_type data;
    
16.         struct node_tag *next;
    
17. } node_t;
    
18. 
    
19. typedef struct
    
20. {
    
21.         node_t *head;
    
22. } list_t;
    
23. 
    
24. void list_init(list_t *l)
    
25. {
    
26.         l->head = (node_t *)malloc(sizeof(node_t));
    
27.         l->head->next = NULL;
    
28. }
    
29. 
    
30. void list_add(list_t *l, const elem_type *e)
    
31. {
    
32.         node_t *node = (node_t *)malloc(sizeof(node_t));
    
33.         node->data = *e;
    
34.         node->next = l->head->next;
    
35.         l->head->next = node;
    
36. }
    
37. 
    
38. void list_clear(list_t *l)
    
39. {
    
40.         node_t *node = l->head->next;
    
41.         while(node)
    
42.         {
    
43.                 node_t *temp = node;
    
44.                 node = node->next;
    
45.                 free(temp);
    
46.         }
    
47.         l->head->next = NULL;
    
48. }
    
49. 
    
50. void list_traverse(const list_t *l)
    
51. {
    
52.         node_t *node = l->head->next;
    
53.         while(node)
    
54.         {
    
55.                 printf("%ld ", node->data.id);
    
56.                 node = node->next;
    
57.         }
    
58.         printf("\n");
    
59. }
    
60. 
    
61. void list_destroy(list_t *l)
    
62. {
    
63.         list_clear(l);
    
64.         free(l->head);
    
65.         l->head = NULL;
    
66. }
    
67. 
    
68. void swap(node_t *a, node_t *b)
    
69. {
    
70.         node_t *temp = a->next;
    
71.         a->next = b->next;
    
72.         b->next = temp;
    
73.         temp = a->next->next;
    
74.         a->next->next = b->next->next;
    
75.         b->next->next = temp;
    
76. }
    
77. 
    
78. // 按id排序
    
79. void sort(list_t *l)
    
80. {
    
81.         for(node_t *i = l->head; i->next; i = i->next)
    
82.         {
    
83.                 for(node_t *j = i->next; j->next; j = j->next)
    
84.                 {
    
85.                         if(i->next->data.id > j->next->data.id)
    
86.                         {
    
87.                                 node_t *i_next = i->next;
    
88.                                 swap(i, j);
    
89.                                 if(i_next == j)                        // 如果i和j紧挨着，交换后j的指向会出错，这里修正一下
    
90.                                         j = i->next;
    
91.                         }
    
92.                 }
    
93.         }
    
94. }
    
95. 
    
96. int main(void)
    
97. {
    
98.         printf("user_info_t size: %ld\n", sizeof(user_info_t));
    
99. 
    
100.         user_info_t info = {0, {0}};
     
101.         list_t l;
     
102.         list_init(&l);
     
103.         for(size_t i = 0; i < 1024; ++i)
     
104.         {
     
105.                 info.id = i;
     
106.                 list_add(&l, &info);
     
107.         }
     
108.         sort(&l);
     
109.         list_traverse(&l);
     
110.         list_destroy(&l);
     
111.         return 0;
     
112. }

复制代码

链表版本用时21ms

因为链表版本只是修改指针指向，并不移动数据元素
我认为这个和排序算法无关，只要两者使用相同的排序算法，链表效率一定高过数组，这是我目前认为的，如果你不同意，请用代码说服我^_^

人造人

Croper 发表于 2019-5-8 22:50
嗯。。。同样的方法两者代码写出来都是同样的数量级(O[nlogn]或O[n^2]，视排序方法不同),但是链表本神 ...

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. typedef struct
   
6. {
   
7.         size_t id;
   
8.         char name[4096];
   
9. } user_info_t;
   
10. 
    
11. typedef user_info_t elem_type;
    
12. 
    
13. typedef struct node_tag
    
14. {
    
15.         elem_type data;
    
16.         struct node_tag *next;
    
17. } node_t;
    
18. 
    
19. typedef struct
    
20. {
    
21.         node_t *head;
    
22. } list_t;
    
23. 
    
24. void list_init(list_t *l)
    
25. {
    
26.         l->head = (node_t *)malloc(sizeof(node_t));
    
27.         l->head->next = NULL;
    
28. }
    
29. 
    
30. void list_add(list_t *l, const elem_type *e)
    
31. {
    
32.         node_t *node = (node_t *)malloc(sizeof(node_t));
    
33.         node->data = *e;
    
34.         node->next = l->head->next;
    
35.         l->head->next = node;
    
36. }
    
37. 
    
38. void list_clear(list_t *l)
    
39. {
    
40.         node_t *node = l->head->next;
    
41.         while(node)
    
42.         {
    
43.                 node_t *temp = node;
    
44.                 node = node->next;
    
45.                 free(temp);
    
46.         }
    
47.         l->head->next = NULL;
    
48. }
    
49. 
    
50. void list_traverse(const list_t *l)
    
51. {
    
52.         node_t *node = l->head->next;
    
53.         while(node)
    
54.         {
    
55.                 printf("%ld ", node->data.id);
    
56.                 node = node->next;
    
57.         }
    
58.         printf("\n");
    
59. }
    
60. 
    
61. void list_destroy(list_t *l)
    
62. {
    
63.         list_clear(l);
    
64.         free(l->head);
    
65.         l->head = NULL;
    
66. }
    
67. 
    
68. void swap(node_t *a, node_t *b)
    
69. {
    
70.         node_t *temp = a->next;
    
71.         a->next = b->next;
    
72.         b->next = temp;
    
73.         temp = a->next->next;
    
74.         a->next->next = b->next->next;
    
75.         b->next->next = temp;
    
76. }
    
77. 
    
78. // 按id排序
    
79. void sort(list_t *l)
    
80. {
    
81.         for(node_t *i = l->head; i->next; i = i->next)
    
82.         {
    
83.                 for(node_t *j = i->next; j->next; j = j->next)
    
84.                 {
    
85.                         if(i->next->data.id > j->next->data.id)
    
86.                         {
    
87.                                 node_t *i_next = i->next;
    
88.                                 swap(i, j);
    
89.                                 if(i_next == j)                        // 如果i和j紧挨着，交换后j的指向会出错，这里修正一下
    
90.                                         j = i->next;
    
91.                         }
    
92.                 }
    
93.         }
    
94. }
    
95. 
    
96. int main(void)
    
97. {
    
98.         printf("user_info_t size: %ld\n", sizeof(user_info_t));
    
99. 
    
100.         user_info_t info = {0, {0}};
     
101.         list_t l;
     
102.         list_init(&l);
     
103.         for(size_t i = 0; i < 1024; ++i)
     
104.         {
     
105.                 info.id = i;
     
106.                 list_add(&l, &info);
     
107.         }
     
108.         sort(&l);
     
109.         list_traverse(&l);
     
110.         list_destroy(&l);
     
111.         return 0;
     
112. }

复制代码

23ms，链表几乎不受数据元素大小的影响

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. typedef struct
   
6. {
   
7.         size_t id;
   
8.         char name[4096];
   
9. } user_info_t;
   
10. 
    
11. void swap(user_info_t *a, user_info_t *b)
    
12. {
    
13.         user_info_t temp = *a;
    
14.         *a = *b;
    
15.         *b = temp;
    
16. }
    
17. 
    
18. // 按id排序
    
19. void sort(user_info_t info[], size_t size)
    
20. {
    
21.         for(size_t i = 0; i < size; ++i)
    
22.         {
    
23.                 for(size_t j = i + 1; j < size; ++j)
    
24.                 {
    
25.                         if(info[i].id > info[j].id)
    
26.                                 swap(&info[i], &info[j]);
    
27.                 }
    
28.         }
    
29. }
    
30. 
    
31. int main(void)
    
32. {
    
33.         printf("user_info_t size: %ld\n", sizeof(user_info_t));
    
34. 
    
35.         user_info_t info[1024];
    
36.         for(size_t i = 0; i < 1024; ++i)
    
37.         {
    
38.                 info[i].id = 1024 - i;
    
39.         }
    
40. 
    
41.         sort(info, 1024);
    
42.         for(size_t i = 0; i < 1024; ++i)
    
43.                 printf("%ld ", info[i].id);
    
44.         printf("\n");
    
45.         return 0;
    
46. }

复制代码

350ms，因为数组在不停的移动数据元素

虽然说name预留4096字节有点夸张，但是这只是为了演示数据元素比较大的情况
name预留4096字节恐怕只有在这里才会出现，但是在现实中数据元素比较大的情况并不罕见

另外，上面也证明了可以用代码量换时间
数组46行，链表112行^_^

Croper

人造人 发表于 2019-5-11 22:24
23ms，链表几乎不受数据元素大小的影响

嗯，你提到了关于数组移动元素的问题，我之前按照楼主的意思，一直把这个数组默认为整数数组，移动元素的时间代价应该是很小的，所以完全没有考虑这一点，

不过你这么一说，我也做了下实验

排序方法以及排序时使用的元素：

1. //关于数组和链表排序速度的实验，排序方法：快排
   
2. 
   
3. #include <time.h>
   
4. #include <random>
   
5. #include <iostream>
   
6. 
   
7. using namespace std;
   
8. 
   
9. //数组和链表的大小
   
10. const int ARRSIZE = 100000;  
    
11. //测试次数
    
12. const int TESTTIME = 10;
    
13. 
    
14. //数组排序
    
15. template <typename T>
    
16. void qsort(T* a, int size) {
    
17.         struct ele {
    
18.                 T* a;
    
19.                 int size;
    
20.         };
    
21.        
    
22.         ele *stk = new ele[ARRSIZE];
    
23.         int c_stk=0;
    
24. 
    
25.         while (size>1){
    
26.                 int p = 0, q = size - 1;
    
27.                 T t = a[0];
    
28.                 T n = a[1];
    
29.                 while (q > p) {
    
30.                         if (n < t) {
    
31.                                 a[p++] = n;
    
32.                                 if (p + 1 < size) n = a[p + 1];
    
33.                         }
    
34.                         else {
    
35.                                 T tmp = a[q];
    
36.                                 a[q--] = n;
    
37.                                 n = tmp;
    
38.                         }
    
39.                 }
    
40.                 a[p] = t;
    
41. 
    
42.                 int size2 = size - p - 1;
    
43.                 if (size2 > 1) stk[c_stk++]={ a + p + 1,size2 };
    
44. 
    
45.                 size = p;
    
46.                 if (size < 2 && c_stk!=0) {
    
47.                         --c_stk;
    
48.                         size = stk[c_stk].size;
    
49.                         a = stk[c_stk].a;
    
50.                 }
    
51.         }
    
52. }
    
53. 
    
54. 
    
55. //链表节点声明
    
56. template <typename T>
    
57. struct Node {
    
58.         T val;
    
59.         Node* next;
    
60.         Node(T n) :val(n), next(nullptr) {};
    
61. };
    
62. 
    
63. //删除链表
    
64. template <typename T>
    
65. void dellist(Node<T>* head) {
    
66.         while (head != nullptr) {
    
67.                 Node<T>* tmp = head->next;
    
68.                 delete head;
    
69.                 head = tmp;
    
70.         }
    
71. }
    
72. 
    
73. 
    
74. //链表排序
    
75. template <typename T>
    
76. void qsort(Node<T>*& head) {
    
77.         struct ele {
    
78.                 Node<T>** begin;
    
79.                 Node<T>* end;
    
80.         };
    
81. 
    
82.         ele *stk = new ele[ARRSIZE];
    
83.         int c_stk = 0;
    
84. 
    
85.         Node<T> **begin = &head;
    
86.         Node<T> *end = nullptr;
    
87.         while (*begin != end && (*begin)->next!=end) {
    
88.                 Node<T> *p = *begin;
    
89.                 Node<T> *mid = *begin;
    
90.                 Node<T> *& newhead=*begin;
    
91.                 while (p->next!=end) {
    
92.                         if (p->next->val < mid->val) {
    
93.                                 Node<T>* tmp = p->next->next;
    
94.                                 p->next->next = newhead;
    
95.                                 newhead = p->next;
    
96.                                 p->next = tmp;
    
97.                         }
    
98.                         else {
    
99.                                 p = p->next;
    
100.                         }
     
101.                 }
     
102. 
     
103.                 if (mid->next != end && mid->next->next != end) {
     
104.                         stk[c_stk++] = { &(mid->next),end };
     
105.                 }
     
106. 
     
107.                 end = mid;
     
108.                 if ((*begin==end || (*begin)->next == end) && c_stk!=0) {
     
109.                         --c_stk;
     
110.                         begin = stk[c_stk].begin;
     
111.                         end = stk[c_stk].end;
     
112.                 }
     
113.         }
     
114. }
     
115. 
     
116. //这是能指定大小的需要排序的元素元素，重载了operator<();
     
117. template <int SIZE>
     
118. struct mulint {
     
119.         int val[SIZE];
     
120.        
     
121.         mulint() {};
     
122.         mulint(int n) {
     
123.                 val[0] = n;
     
124.         }
     
125.         mulint& operator=(int n) {
     
126.                 val[0] = n;
     
127.                 return *this;
     
128.         }
     
129.         bool operator<(const mulint& m2) {
     
130.                 return val[0] < m2.val[0];
     
131.         }
     
132. };

复制代码

测试代码

1. template <int N>
   
2. void test() {
   
3.         clock_t t1, t2;
   
4.         t1 = t2 = 0;
   
5. 
   
6.         for (int i = 0; i < TESTTIME; ++i) {
   
7.                 //初始化数组和链表，保证其中的元素完全一样
   
8.                 mulint<N> a[ARRSIZE];
   
9.                 Node<mulint<N>>* preb = new Node<mulint<N>>(0);
   
10.                 Node<mulint<N>>* p = preb;
    
11. 
    
12.                 for (int j = 0; j < ARRSIZE; ++j) {
    
13.                         int t = rand() % ARRSIZE;
    
14.                         a[j] = t;
    
15.                         p->next = new Node<mulint<N>>(t);
    
16.                         p = p->next;
    
17.                 }
    
18. 
    
19.                 //测试排序时间
    
20.                 clock_t t = clock();
    
21.                 qsort(a, ARRSIZE);
    
22.                 t1 += clock() - t;
    
23. 
    
24. 
    
25.                 t = clock();
    
26.                 qsort(preb->next);
    
27.                 t2 += clock() - t;
    
28. 
    
29.                 dellist(preb);
    
30.         }
    
31. 
    
32.         cout <<"数据大小："<<N<< " 数组排序耗费时间：" << t1 << endl;
    
33.         cout <<"数据大小："<<N<< " 链表排序耗费时间：" << t2 << endl;
    
34. }
    
35. 
    
36. int main() {
    
37.         test<1>();
    
38.         test<10>();
    
39.         test<20>();
    
40.         test<30>();
    
41.         test<40>();
    
42.         test<50>();
    
43.         test<60>();
    
44.         test<70>();
    
45.         test<80>();
    
46.         test<90>();
    
47.         system("pause");
    
48. }

复制代码

测试结果：
数据大小：1 数组排序耗费时间：784
数据大小：1 链表排序耗费时间：1059
数据大小：10 数组排序耗费时间：1279
数据大小：10 链表排序耗费时间：1026
数据大小：20 数组排序耗费时间：1454
数据大小：20 链表排序耗费时间：1082
数据大小：30 数组排序耗费时间：1486
数据大小：30 链表排序耗费时间：1124
数据大小：40 数组排序耗费时间：1661
数据大小：40 链表排序耗费时间：1134
数据大小：50 数组排序耗费时间：1677
数据大小：50 链表排序耗费时间：1147
数据大小：60 数组排序耗费时间：1735
数据大小：60 链表排序耗费时间：1194
数据大小：70 数组排序耗费时间：1772
数据大小：70 链表排序耗费时间：1167
数据大小：80 数组排序耗费时间：1670
数据大小：80 链表排序耗费时间：1177
数据大小：90 数组排序耗费时间：1830
数据大小：90 链表排序耗费时间：1220

嗯。。。看起来似乎数组并没有多大优势，
但是仔细想一想，似乎在哪里看过，数组访问速度的优势很大程度是因为其能通过基于cpu加速，而链表必须老老实实访问内存。
但是debug模式下，这个优势并没有得到体现，于是改成了release模式，再次测试：


数据大小：1 数组排序耗费时间：69
数据大小：1 链表排序耗费时间：265
数据大小：10 数组排序耗费时间：93
数据大小：10 链表排序耗费时间：324
数据大小：20 数组排序耗费时间：115
数据大小：20 链表排序耗费时间：350
数据大小：30 数组排序耗费时间：164
数据大小：30 链表排序耗费时间：394
数据大小：40 数组排序耗费时间：257
数据大小：40 链表排序耗费时间：405
数据大小：50 数组排序耗费时间：337
数据大小：50 链表排序耗费时间：424
数据大小：60 数组排序耗费时间：381
数据大小：60 链表排序耗费时间：520
数据大小：70 数组排序耗费时间：481
数据大小：70 链表排序耗费时间：445
数据大小：80 数组排序耗费时间：528
数据大小：80 链表排序耗费时间：424
数据大小：90 数组排序耗费时间：632
数据大小：90 链表排序耗费时间：520

结果比较明显了，在数据大小比较小的时候，数组排序的效率能达到链表的三到四倍左右。
在数据大小大概为70*sizeof(int)=280Byte左右，两者速度差不多；再大一些，就是链表的优势区了

Croper

之后继续想了一下。。数据大的话谁会到处移动数据啊。。
正常来说，不应该是建立一个索引，然后通过索引访问么。。？

所以再次试了一下，这次为数组建立索引，然后通过索引访问数组，排序时也只移动索引，不移动元素本身：

1. 
   
2. //索引
   
3. template <int N>
   
4. struct mptr {
   
5.         mulint<N>* p;
   
6.         bool operator<(const mptr& p2) {
   
7.                 return p->val[0] < p2.p->val[0];
   
8.         }
   
9. };
   
10. 
    
11. 
    
12. template <int N>
    
13. void test2() {
    
14.         clock_t t1, t2;
    
15.         t1 = t2 = 0;
    
16. 
    
17.         for (int i = 0; i < TESTTIME; ++i) {
    
18.                 //初始化数组和链表，保证其中的元素完全一样
    
19.                 mulint<N> a[ARRSIZE];
    
20.                 Node<mulint<N>>* preb = new Node<mulint<N>>(0);
    
21.                 Node<mulint<N>>* p = preb;
    
22. 
    
23.                 for (int j = 0; j < ARRSIZE; ++j) {
    
24.                         int t = rand() % ARRSIZE;
    
25.                         a[j] = t;
    
26.                         p->next = new Node<mulint<N>>(t);
    
27.                         p = p->next;
    
28.                 }
    
29. 
    
30.                 //建立数组的索引：
    
31.                 mptr<N> index[ARRSIZE];
    
32.                 for (int j = 0; j < ARRSIZE; ++j) {
    
33.                         index[j].p = a + j;
    
34.                 }
    
35.                 //测试排序时间
    
36.                 clock_t t = clock();
    
37.                 qsort(index, ARRSIZE);
    
38.                 t1 += clock() - t;
    
39. 
    
40.                 t = clock();
    
41.                 qsort(preb->next);
    
42.                 t2 += clock() - t;
    
43. 
    
44.                 dellist(preb);
    
45.         }
    
46. 
    
47.         cout << "数据大小：" << N << " 数组排序耗费时间：" << t1 << endl;
    
48.         cout << "数据大小：" << N << " 链表排序耗费时间：" << t2 << endl;
    
49. }
    
50. 
    
51. int main() {
    
52.         test2<1>();
    
53.         test2<10>();
    
54.         test2<20>();
    
55.         test2<30>();
    
56.         test2<40>();
    
57.         test2<50>();
    
58.         test2<60>();
    
59.         test2<70>();
    
60.         test2<80>();
    
61.         test2<90>();
    
62.         system("pause");
    
63. }
    

复制代码

结果：
数据大小：1 数组排序耗费时间：118
数据大小：1 链表排序耗费时间：328
数据大小：10 数组排序耗费时间：112
数据大小：10 链表排序耗费时间：347
数据大小：20 数组排序耗费时间：129
数据大小：20 链表排序耗费时间：353
数据大小：30 数组排序耗费时间：136
数据大小：30 链表排序耗费时间：389
数据大小：40 数组排序耗费时间：136
数据大小：40 链表排序耗费时间：391
数据大小：50 数组排序耗费时间：140
数据大小：50 链表排序耗费时间：429
数据大小：60 数组排序耗费时间：149
数据大小：60 链表排序耗费时间：512
数据大小：70 数组排序耗费时间：150
数据大小：70 链表排序耗费时间：445
数据大小：80 数组排序耗费时间：157
数据大小：80 链表排序耗费时间：439
数据大小：90 数组排序耗费时间：153
数据大小：90 链表排序耗费时间：490

可以看到，通过索引访问数组之后，数组的排序速度基本是3倍于链表，
更不用说数组在随机访问等其他方面的优势了
所以综上：
我仍然认为链表的排序速度低于数组

人造人

Croper 发表于 2019-5-12 11:48
之后继续想了一下。。数据大的话谁会到处移动数据啊。。
正常来说，不应该是建立一个索引，然后通过索引访 ...

今天我花时间研究了一下这部分内容
只要把 数组中存储对象本身 改为 数组中存储对象指针，链表的排序优势就不复存在

你赢了^_^
但前提是 数组中存储对象指针