排序技术哪家强，各种排序算法。

liht1634

很不错了。

Sammy673

看看

ko12

太强了。特别是图。

Munly

学习

liucun

不错

？？？

看看！！！！！

yuexinBW

6666666

cqj9006

厉害厉害~~

kworth

gif图片很形象呀，代码不明学历:sweat:

夜伴街头

太厉害了!学习下！

yang4225231

好强大的样子，我只是来看看，虽然某些我还看不懂

devil5975

这个不错，代码都有

雨声绝晴

6666666666666666666666666:big

小海儿~

呃终于写完了 我写的c++的 才发现是Python板块的 不好意思哇

1. //-----------------冒泡排序--------------------
   
2. void bubblesort()
   
3. {       
   
4.         int i, j,flag,temp;
   
5.         for (i = 0; i <= 1999; i++)
   
6.         {       
   
7.                 flag = 0;
   
8.                 for (j = 0; j <= 1999 - i; j++)
   
9.                 {       
   
10.                         if (b[j] > b[j + 1])
    
11.                         {
    
12.                                 temp = b[j];
    
13.                                 b[j] = b[j + 1];
    
14.                                 b[j + 1] = temp;
    
15.                                 flag = 1;
    
16.                         }
    
17.                 }
    
18.                 if (!flag) break;
    
19.         }
    
20. }
    
21. 
    
22. //-----------------快速排序1--------------------
    
23. 
    
24. void quicksort1(int left,int right)
    
25. {
    
26.         int i, j, t, temp;
    
27.         if (left > right)
    
28.                 return;
    
29.         i = left;
    
30.         j = right;
    
31.         temp = a[left];
    
32.        
    
33.         while (i!=j)
    
34.         {
    
35.                 while (i < j&&a[j] >= temp)
    
36.                         --j;
    
37.                 while (i < j&&a[i] <= temp)
    
38.                         ++i;
    
39.                 if (i<j)
    
40.                         t = a[j]; a[j] = a[i]; a[i] = t;
    
41.                
    
42.         }
    
43.         a[left] = a[i];
    
44.         a[i] = temp;
    
45. 
    
46.         quicksort1(left,i-1);
    
47.         quicksort1(i+1,right);
    
48. 
    
49. }
    
50. //-----------------快速排序2--------------------
    
51. 
    
52. int part(int left, int right)
    
53. {
    
54.         int temp = a[left];
    
55.         int pivot = a[left];
    
56.         while (left < right)
    
57.         {
    
58.                 while (left < right&&a[right] >= pivot) right--;
    
59.                 a[left] = a[right];
    
60. 
    
61.                 while (right > left&&a[left] <= pivot) left++;
    
62.                 a[right] = a[left];
    
63.         }
    
64. 
    
65.         a[left] = temp;
    
66.         return left;
    
67. 
    
68. }
    
69. void quicksort(int left, int right)
    
70. {
    
71.         if (left < right)
    
72.         {
    
73.                 int flag = part(left, right);
    
74.                 quicksort(left, flag - 1);
    
75.                 quicksort(flag+1,right);
    
76.         }
    
77. 
    
78. }
    
79. 
    
80. 
    
81. //-----------------直接插入排序--------------------
    
82. void insertsort()
    
83. {
    
84.         int i, j, temp;
    
85. 
    
86.         for (i = 1; i < 2000; i++)//a[0]作监视哨
    
87.         {
    
88.                 temp = a[i];
    
89.                 j = i - 1;
    
90.                
    
91.                 while (a[j]>temp && j >= 0)
    
92.                 {
    
93.                         a[j + 1] = a[j];//后移
    
94.                         --j;
    
95.                 }
    
96. 
    
97.                 a[j + 1] = temp;
    
98.         }
    
99. }
    
100. 
     
101. //-----------------希尔排序--------------------
     
102. void shellsort()
     
103. {       
     
104.         int i, j,temp,k;
     
105.         int d;//间隔
     
106.        
     
107.         for (d = 2000 / 2; d > 0;d/=2)
     
108.         {
     
109.                 //直接插入排序
     
110.                 for (k = 0; k < d; ++k)
     
111.                 {
     
112.                         for (i = k+d; i < 2000; i += d)
     
113.                         {
     
114.                                 temp = a[i];
     
115.                                 j = i - d;
     
116. 
     
117.                                 while (a[j]>temp && j >= k)
     
118.                                 {
     
119.                                         a[j + d] = a[j];
     
120.                                         j -= d;
     
121.                                 }
     
122.                                 a[j + d] = temp;
     
123.                         }
     
124.                 }
     
125. 
     
126.         }
     
127. }
     
128. //-----------------堆排序--------------------
     
129. void swap(int& x, int& y)
     
130. {
     
131.         int temp = x;
     
132.         x = y;
     
133.         y = temp;
     
134. }
     
135. 
     
136. void HeapAdjust(int i,int n)
     
137. {
     
138.         int j, temp;
     
139.         temp = a[i];
     
140.         j = 2 * i + 1;
     
141. 
     
142.         while (j<n)
     
143.         {
     
144.                 if (j+1<n && a[j] < a[j + 1])
     
145.                 {
     
146.                         j++;
     
147.                 }
     
148.                
     
149.                 if (temp>=a[j])        break;                       
     
150.                
     
151.                 a[i] = a[j];
     
152.                 i = j;
     
153.                 j = 2 * i + 1;
     
154.         }
     
155. 
     
156.         a[i]=temp;
     
157. }
     
158. 
     
159. void Heapsort()
     
160. {
     
161.         int i;
     
162. 
     
163.         for (i = 2000/ 2-1; i >= 0; i--)
     
164.         {
     
165.                 HeapAdjust(i,2000);
     
166.         }
     
167. 
     
168.         for (i = 1999; i > 0; i--)
     
169.         {
     
170.                 swap(a[0],a[i]);
     
171.                 HeapAdjust(0,i-1);
     
172.         }
     
173. }
     
174. 
     
175. //-----------------归并排序--------------------
     
176. void merge(int*left,int left_length,int *right,int right_length)
     
177. {
     
178.         int i, j, k,m;
     
179.         i = j = k = 0;
     
180. 
     
181.         while (i<left_length && j<right_length)
     
182.         {
     
183.                 if (left[i] < right[j])
     
184.                         temp[k++] = left[i++];
     
185.                 else
     
186.                         temp[k++] = right[j++];
     
187.         }
     
188. 
     
189.         while (i < left_length)
     
190.                 temp[k++] = left[i++];
     
191.         while (j < right_length)
     
192.                 temp[k++] = right[j++];
     
193. 
     
194.         for ( m = 0; m < (left_length+right_length); m++)
     
195.                 left[m] = temp[m];
     
196. }
     
197. void mergesort(int* x, int n)
     
198. {
     
199.         if (n >= 2)
     
200.         {
     
201.                 int *left = x;
     
202.                 int left_length = n / 2;
     
203. 
     
204.                 int *right = x + left_length;
     
205.                 int right_length = n - left_length;
     
206. 
     
207.                 mergesort(left, left_length);
     
208.                 mergesort(right, right_length);
     
209. 
     
210.                 merge(left, left_length, right, right_length);
     
211.         }
     
212. }
     

复制代码

小海儿~

小海儿~ 发表于 2014-12-11 20:37
呃终于写完了 我写的c++的 才发现是Python板块的 不好意思哇

谢谢:big 感觉你也很厉害啊 python我还没开始学

cbt

Nice

菜子zzk

学习了

herdboy

果断收藏了

gelebo

:funk:厉害了~~~~~~

pythoncherry

太帅了