排序总结

  1 #include<stdio.h>
  2 //分治思想
  3 //分类----------------内部比较排序
  4 //数据结构------------数组
  5 //最差时间复杂度------每次选取的基准都是最大或者最小的元素，导致每次只划分出
  6 //了一个分区。需要进行n-1次划分才能结束递归，时间复杂度为O(n^2)
  7 //最优时间复杂度------每次选取的基准都是中位数，这样每次都均匀的划分出两个区域
  8 //只需要logn次划分就能结束递归，时间复杂度为O(nlogn)
  9 //平均时间复杂度------O(nlogn)
 10 //所需辅助空间--------主要是递归造成的栈空间的使用（用来保存left和right等局部变量）
 11 //取决于递归树的深度，一般为O(logn),最差为O(n)
 12 //稳定性---------------不稳定
 13 
 14 void Swap(int arr[],int i,int j)
 15 {
 16     int tmp = arr[i];
 17     arr[i] = arr[j];
 18     arr[j] = tmp;
 19 }
 20 int Partition(int arr[],int left,int right)//划分函数
 21 {
 22     int pivor = arr[right];//每次都选择最后一个元素做基准
 23     int tail =left -1;//tail为小于基准的子数组最后一个元素的 索引
 24 
 25     for(int i = left;i < right;++i)//遍历基准以外的其他元素
 26     {
 27         if(arr[i] <= pivor)
 28         {
 29             Swap(arr,++tail,i);
 30         }
 31     }
 32     Swap(arr,tail+1,right);//该操作有可能把后边元素的稳定性打乱
 33 
 34     return tail + 1;
 35 }
 36 void QuickSort(int *arr,int left,int right)
 37 {
 38     if(left >= right)
 39     {
 40         return ;
 41     }
 42     int pivor_index = Partition(arr,left,right);
 43     QuickSort(arr,left,pivor_index-1);
 44     QuickSort(arr,pivor_index+1,right);
 45 }
 46 
 47 //分类-------------内部比较排序
 48 //数据结构---------数组
 49 //最差时间复杂度---O(n^2)
 50 //最优时间复杂度---    O(n^2)
 51 //平均时间复杂度----O(n^2)
 52 //所需辅助空间------O(1)
 53 //稳定性------------不稳定
 54 void select_sort(int arr[],int len)
 55 {
 56     
 57     for(int i = 0; i < len -1;++i)
 58     {
 59         int min = i;
 60         for(int j = i+1;j < len;j++)
 61         {
 62             if(arr[min] > arr[j])
 63             {
 64                 min = j;
 65             }
 66         }
 67         if(min != i)
 68         {
 69             swap(arr,min,i);
 70         }
 71     }
 72     return ;
 73 }
 74 //分类--------------内部比较排序
 75 //数据结构----------数组
 76 //最差时间复杂度 ---根据步长序列的不同而不同，已知最好的为O(n(logn)^2)
 77 //最优时间复杂度----O(n)
 78 //平均时间复杂度----根据步长的不同而不同
 79 //所需辅助空间------O(1)
 80 //稳定性------------不稳定
 81 void ShellSort(int *arr,int len)
 82 {
 83     int h = 0;
 84     while(h <= len)
 85     {
 86         h = 3*h+1;
 87     }
 88     while(h >=1 )
 89     {
 90         for(int i = h;i < len;++i)
 91         {
 92              int j = i-h;
 93              int get = arr[i];
 94              while(j >=0 && arr[j] > get)
 95              {
 96                 arr[j+h] = arr[j];
 97                 j = j-h;
 98              }
 99              arr[j+h] = get;
100         }
101         h = (h-1)/3;
102     }
103     
104 }
105 //分类----------------------内部比较排序
106 //数据结构------------------数组
107 //最差时间复杂度-----------O(nlogn)
108 //最优时间复杂度-----------O(nlogn)
109 //平均时间复杂度-----------O(nlogn)
110 //所需辅助空间-------------O(n)
111 //稳定性-------------------稳定
112 
113 
114 void Merge(int *arr,int left,int mid,int right)
115 {
116     int len = right - left + 1;
117     int *tmp = new int[len];//辅助空间
118     int index = 0;
119     int i = left;//前一数组的起始元素
120     int j = mid + 1;//后一数组的起始元素
121     while(i <=mid && j <= right)
122     {
123         tmp[index++] = arr[i] <= arr[j]? arr[i++]:arr[j++];//等号保证稳定性
124     }
125     while(i <= mid)
126     {
127         tmp[index++] = arr[i++];
128     }
129     while(j <= right)
130     {
131         tmp[index++] = arr[j++];
132     }
133 
134     for(int k = 0; k < len; k++)
135     {
136         arr[k] = tmp[k];
137     }
138 }
139 ///////////////////////////////////////////////////
140 
141 void MergeSortInteration(int *arr,int len)//非递归（迭代）实现的归并排序(自底向上)
142 {
143     int left,mid,right;//子数组索引，前一个为arr[left...mid]，
144                      //后一个为arr[mid+1...right]
145     for(int i = 1;i < len; i*=2)
146     {
147         left = 0;
148         while(left+i < len)
149         {
150             mid = left +i -1;
151             right = mid + i < len?mid+i:len-1;//后一个数组大小可能不够
152             Merge(arr,left,mid,right);
153             left =right + 1;
154         }
155     }
156 }
157 ////////////////////////////////////////////
158 
159 void MergeSortRecursion(int *arr,int left,int right)//递归实现的归并（自顶向下）
160 {
161     if(left == right)//当待排序的序列长度为1时，递归开始回溯，进行Merge操作
162     {
163         return;
164     }
165     int mid = (left + right)/2;
166     MergeSortRecursion(arr,left,mid);
167     MergeSortRecursion(arr,mid+1,right);
168     Merge(arr,left,mid,right);    
169 }
170 //分类---------------内部比较排序
171 //数据结构-----------数组
172 //最差时间复杂度-----O(n^2)
173 //最优时间复杂度-----O(nlogn)
174 //平均时间复杂度-----O(n^2)
175 //所需辅助空间-------O(1)
176 //稳定性-------------稳定
177 
178 void InsertSortDichotomy(int *arr,int len)
179 {
180     for(int i = 1;i < len;++i)
181     {
182         int tmp = arr[i];
183         int left = 0;
184         int right = i-1;
185 
186         while(left <= right)
187         {
188             int mid = (left + right)/2;
189             if(arr[mid] > tmp)
190                 right = mid -1;
191             else
192                 left = mid + 1;
193         }
194 
195         for(int j = i-1;j >= left;--j)
196         {
197             arr[j+1] = arr[j];
198         }
199         arr[left] = tmp;
200     }
201 }
202 //分类--------------内部比较排序
203 //数据结构----------数组
204 //最差时间复杂度----最坏情况为输入序列式降序排列的，此时时间复杂度为O(n^2)
205 //最优时间复杂度----最优情况是输入序列是升序排列的，此时时间复杂度为O(n)
206 //平均时间复杂度----O(n^2)
207 //所需辅助空间------O(1)
208 //稳定性------------稳定
209 
210 
211 void InsertionSort(int *arr,int len)
212 {
213     for(int i = 1; i < len;++i)
214     {
215         int tmp = arr[i];
216         int j =i-1;
217         while(j>=0 && arr[j]>tmp)
218         {
219             arr[j+1] = arr[j];
220             j--;
221         }
222         arr[j+1] = tmp;
223 
224     }
225 }
226 //堆排序
227 void AdjustArr(int *arr,int index,int len)
228 {
229     int tmp = arr[index];
230     for(int i = 2*index+1;i < len;i=i*2+1)
231     {
232         if(i+1 < len && arr[i+1]>arr[i])
233         {
234             i+=1;
235         }
236         if(arr[i] > tmp)
237         {
238             arr[index] = arr[i];
239             index = i;
240         }
241         else
242         {
243             break;
244         }
245     }
246     arr[index ] = tmp;
247 }
248 void HeapSort(int *arr,int len)
249 {
250     for(int i = len/2-1;i >=0;--i)
251     {
252         AdjustArr(arr,i,len);
253     }
254     for(int j = len - 1;j > 0;--j)
255     {
256         Swap(arr,j,0);
257         AdjustArr(arr,0,j);
258     }
259 }
260 
261 //冒泡排序
262 void BubbleSort(int arr[],int len)
263 {
264     for(int i = 0;i < len-1;i++)
265     {
266         for(int j = 0; j < len-i-1;j++)
267         {
268             if(arr[j] > arr[j+1])
269                 Swap(arr,j,j+1);
270         }
271     }
272 }