13:50:24 2019-09-14

继续把未看完的看完

 

排序算法

定理:任意$N$个不同元素组成的序列平均具有$N(N-1)/4$个逆序对

定理:任何仅以交换相邻两元素来排序的算法，其平均时间复杂度为$Ω(N^2)$

这样子 冒泡排序 插入排序 的最坏情况都是 N^2

要使排序算法变高效 得使用间隔元素来交换 在一次排序中 交换多个逆序对的元素

 

希尔排序

定义增量序列$D_M>D_{M-1}>...>D_1=1$

$对每个D_k进行“D_k-间隔”排序（k=M,M-1,...1)$

$注意：“D_k-间隔"有序的序列，在执行”D_{k-1}间隔“排序后，仍然是“D_k-间隔"有序的$

如果增量元素不互质，则小增量可能根本不起作用

比如 $N=N/2$ 最坏情况 时候 $T=\theta(N^{2})$

那么就会有其他的增量序列:

　　Hibbard增量序列 $D_k=2^k-1$  --相邻元素互质  最坏情况$T=\theta(N^{3/2})$

　　猜想 Hibbard增量的 平均复杂度 $T_{avg}=O(N^{5/4})$

　　Sedgewick增量序列 $ \{1,5,19,41,109,.....\}$

　　$9*4^i-9*2^i或4^i-3*2^i+1$猜想$T_{avg}=O(N^{7/6})  T_{worst}=O(N^{4/3})$

 

冒泡排序 插入排序 希尔排序 选择排序 堆排序 归并排序(ps:其中堆排序写的是憨憨版本 之后会添上精明版本)

  1 #define _CRT_SECURE_NO_WARNINGS  
  2 #include<stdio.h>
  3 #include<malloc.h>
  4 void Print(int A[], int N)
  5 {
  6     for (int i = 0; i < N; i++)
  7         printf("%d ", A[i]);
  8     printf("\n");
  9 }
 10 //排序算法
 11 
 12 //冒泡排序   //最好 O(N) 最坏 O(N^2)  算法稳定
 13 void Swap(int A[], int i, int j)
 14 {
 15     int temp = A[i];
 16     A[i] = A[j];
 17     A[j] = temp;
 18 }
 19 void Bubble_Sort(int A[], int N)
 20 {
 21     for (int i = 0; i < N; i++)
 22     {
 23         int IsSwap = 0;
 24         for (int j = 0; j < N - i-1; j++)
 25         {
 26             if (A[j] > A[j + 1])
 27             {
 28                 IsSwap = 1;
 29                 Swap(A, j, j + 1);
 30             }
 31         }
 32         if (!IsSwap)
 33             break;
 34     }
 35 }
 36 
 37 //插入排序  //最好O(N) 最坏 O(N^2)  算法稳定
 38 void Insert(int A[], int j, int i) 
 39 {
 40     int temp = A[i];
 41     for (; i > j; i--)
 42         A[i] = A[i - 1];
 43     A[j] = temp;
 44 }
 45 void Insert_Sort(int A[], int N)
 46 {
 47     /*for (int i = 0; i < N-1; i++)
 48     {
 49         int m = i + 1;
 50         int j = i;
 51         while (j >= 0 && A[j] > A[m])
 52             j--;
 53         Insert(A, j+1, m);
 54     }*/
 55     /*for (int i = 1; i < N; i++)
 56     {
 57         int temp = A[i];
 58         int j;
 59         for (j = i - 1; j >= 0 && A[j] > temp; j--)
 60             A[j + 1] = A[j];
 61         A[j + 1] = temp;
 62     }*/
 63     for (int p = 1; p < N; p++)
 64     {
 65         int temp = A[p];
 66         int i;
 67         for (i = p; i > 0 && A[i - 1] > temp; i--)
 68             A[i] = A[i - 1];
 69         A[i] = temp;
 70     }
 71 }
 72 
 73 //希尔排序  //最坏情况  //改进插入排序
 74 void Shell_Sort(int A[], int N)
 75 {
 76     /*for (int D = N / 2; D > 0; D /= 2)
 77     {
 78         for (int p = D; p < N; p++)
 79         {
 80             int temp = A[p];
 81             int i;
 82             for (i = p; i >= D && A[i - D] > temp; i -= D)
 83                 A[i] = A[i - D];
 84             A[i] = temp;
 85         }
 86     }*/
 87     // 利用Sedgewick增量序列
 88     int Si;
 89     int Sedgewick[] = { 929,505,209,109,41,19,5,1,0 };
 90     for (Si = 0; Sedgewick[Si] >=N; Si++)  //初始的增量Sedgewick[Si]不能超过待排序序列长度
 91         ;
 92     for (int D = Sedgewick[Si]; D>0;D=Sedgewick[++Si])
 93     {
 94         for (int p = D; p < N; p++)
 95         {
 96             int temp = A[p];
 97             int i;
 98             for (i = p; i >= D && A[i - D] > temp; i -= D)
 99                 A[i] = A[i - D];
100             A[i] = temp;
101         }
102     }
103 }
104 
105 //选择排序
106 void Selection_Sort(int A[], int N)
107 {
108     for (int i = 0; i < N; i++)
109     {
110         int MinPosition = i;
111         int Min = A[i];
112         int j;
113         for (j = i + 1; j < N; j++)
114         {
115             if (A[j] < Min)
116             {
117                 MinPosition = j;
118                 Min = A[j];
119             }
120         }
121         Swap(A, i, MinPosition);
122     }
123 }
124 
125 //堆排序  //选择排序的一种改进
126 //改进了寻找最小元的算法 利用最小堆来实现
127 typedef struct HeapStruct* MinHeap;
128 struct HeapStruct
129 {
130     int* Elements;
131     int Size;
132     int Capacity;
133 };
134 MinHeap Create(int MaxSize)
135 {
136     MinHeap H = (MinHeap)malloc(sizeof(struct HeapStruct));
137     H->Elements = (int*)malloc(sizeof(int) * (MaxSize + 1));
138     H->Capacity = MaxSize;
139     H->Size = 0;
140     H->Elements[0] = -10001;
141     return H;
142 }
143 MinHeap H = Create(20);
144 //建立最小堆
145 void PrecDown(MinHeap H, int i)  //下滤
146 {
147     int Parent, Child;
148     int Tmp = H->Elements[i];
149     for (Parent = i; Parent * 2 <= H->Size; Parent = Child)
150     {
151         Child = Parent * 2;
152         if ((Child != H->Size) && (H->Elements[Child] > H->Elements[Child + 1]))
153             Child++;
154         if (Tmp <= H->Elements[Child])break;
155         else
156             H->Elements[Parent] = H->Elements[Child];
157     }
158     H->Elements[Parent] = Tmp;
159 }
160 void BuildMinHeap(MinHeap H)
161 {
162     int i;
163     for (i = H->Size / 2; i > 0; i--)
164         PrecDown(H, i);
165 }
166 int DeleteMin(MinHeap H)
167 {
168     int Parent, Child;
169     int MinItem, temp;
170     MinItem = H->Elements[1];
171     temp = H->Elements[H->Size--];
172     for (Parent = 1; Parent * 2 <= H->Size; Parent = Child)
173     {
174         Child = Parent * 2;
175         if (Child != H->Size && H->Elements[Child] > H->Elements[Child + 1])
176             Child++;
177         if (H->Elements[Child] >= temp)break;
178         else
179             H->Elements[Parent] = H->Elements[Child];
180     }
181     H->Elements[Parent] = temp;
182     return MinItem;
183 }
184 void Heap_Sort(int A[], int N)   
185 {
186     //算法一 利用最小堆
187     /*int Tmp[10] = { 0 };
188     for (int i = 0; i < 10; i++)
189         Tmp[i] = DeleteMin(H);
190     for (int i = 0; i < 10; i++)
191         A[i] = Tmp[i];*/
192     /*for (int i = 0; i < 10; i++)
193         A[i] = DeleteMin(H);*/
194 
195     //算法二 利用最大堆后 再调整
196 }
197 
198 //归并排序
199 void Merge(int A[],int lo,int mi,int hi)
200 {
201     //两个有序序列的合并
202     int* B = (int*)malloc(sizeof(int) * (mi - lo));
203     for (int i = 0; i < mi - lo;)B[i++] = A[lo + i];
204     int i, j, k; 
205     i = lo;
206     j = 0;
207     k = mi;
208     /*while (j<mi-lo||k<hi)
209     {
210         if((j<mi-lo)&&(k>=hi||B[j]<=A[k]))A[i++]=B[j++];
211         if ((k < hi) && (j >= mi-lo|| B[j] > A[k]))A[i++] = A[k++];
212     }*/
213     //化简版
214     while (j<mi-lo)
215     {
216         if (k >= hi || B[j] <= A[k])A[i++] = B[j++];
217         if (k<hi && B[j]>A[k])A[i++] = A[k++];
218     }
219     /*邓公版本*/
220     /*int* A1= A + lo;
221     int* B = (int*)malloc(sizeof(int) * (mi - lo));
222     for (int i = 0; i < mi - lo; B[i] = A1[i++]);
223     int* C = A + mi;
224     int i, j, k;*/
225     /*for (i = j = k = 0; j < mi - lo || k < hi-mi;)
226     {
227         if (j < mi - lo&&((k >= hi - mi)||B[j] <=C[k]))A1[i++] = B[j++];
228         if (k < hi - mi && (j >= mi - lo || B[j] > C[k]))A1[i++] = C[k++];
229     }*/
230     //简化
231     /*for (i = j = k = 0; j < mi - lo;)
232     {
233         if (k >= hi - mi || B[j] <= C[k])A1[i++] = B[j++];
234         if (k < hi - mi && (j >= mi - lo || B[j] > C[k]))A1[i++] = C[k++];
235     }*/
236 }
237 void MergeSort(int A[],int lo,int hi)
238 {
239     if (lo == hi - 1)
240         return;
241     int mi = (lo + hi) >> 1;
242     MergeSort(A,lo, mi);
243     MergeSort(A, mi, hi);
244     Merge(A,lo, mi, hi);
245 }
246 int main() 
247 {
248     int A[10];
249     for (int i = 0; i < 10; i++)
250         scanf("%d", &A[i]);
251     //Bubble_Sort(A, 10);
252     //Insert_Sort(A, 10);
253     //Shell_Sort(A, 10);
254     //Selection_Sort(A, 10);
255     //堆排序
256     /*for (int i = 1; i <= 10; i++)
257         H->Elements[++H->Size] = A[i - 1];
258     BuildMinHeap(H);   //构建最小堆
259     Heap_Sort(A, 10);*/
260     MergeSort(A,0,10);
261     Print(A, 10);
262     return 0;
263 }

View Code