//分治思想
//分類----------------內部比較排序
//數據結構------------數組
//最差時間復雜度------每次選取的基準都是最大或者最小的元素，導致每次只劃分出
//了一個分區。需要進行n-1次劃分才能結束遞歸，時間復雜度為O(n^2)
//最優時間復雜度------每次選取的基準都是中位數，這樣每次都均勻的劃分出兩個區域
//只需要logn次劃分就能結束遞歸，時間復雜度為O(nlogn)
//平均時間復雜度------O(nlogn)
//所需輔助空間--------主要是遞歸造成的棧空間的使用（用來保存left和right等局部變量）
//取決於遞歸樹的深度，一般為O(logn),最差為O(n)
//穩定性---------------不穩定

void Swap(int arr[],int i,int j)
{
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
int Partition(int arr[],int left,int right)//劃分函數
{
int pivor = arr[right];//每次都選擇最後一個元素做基準
int tail =left -1;//tail為小於基準的子數組最後一個元素的 索引

for(int i = left;i < right;++i)//遍歷基準以外的其他元素
{
if(arr[i] <= pivor)
{
Swap(arr,++tail,i);
}
}
Swap(arr,tail+1,right);//該操作有可能把後邊元素的穩定性打亂

return tail + 1;
}
void QuickSort(int *arr,int left,int right)
{
if(left >= right)
{
return ;
}
int pivor_index = Partition(arr,left,right);
QuickSort(arr,left,pivor_index-1);
QuickSort(arr,pivor_index+1,right);
}

  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 }

void BubbleSort(int arr[],int len)
{
for(int i = 0;i < len-1;i++)
{
for(int j = 0; j < len-i-1;j++)
{
if(arr[j] > arr[j+1])
Swap(arr,j,j+1);
}
}
}

排序總結