基礎排序專題（從插入選擇到快排分治）

2021-10-24 08:20:21 字數 3836 閱讀 7217

#include


using


namespace std;


void


isort


(vector<


int>


& a,


int len)


a[j +1]


= key;


//break條件：1)已經找到陣列邊界 


}//2)已經找到與基準數相比較小等於數，查詢結束 


}int


main()
在陣列幾乎有序的情況下時間複雜度為o(n)

最差o(n²)

穩定

#include


using


namespace std;


void


ssort


(vector<


int>


& a,


int len)


swap


(a[i]


,a[tem]);


//交換 i處以前為已排序部分}}


intmain()
最差，最好，平均時間複雜度都是o(n²)

不穩定

#include


using


namespace std;


void


bsort


(vector<


int>


& a,


int len)}}


}int


main()
穩定

平均時間複雜度是o(n²)

#include


using


namespace std;


void


print


(vector<


int>


& a,


int len)


void


csort


(vector<


int>


& a,


int len)


int w = max - min;


//大小差值分塊


vector<


int>


t(w+1)


;//0 - w


for(


int i =


0;i < len;i++


) t[a[i]


- min]++;


int sum =0;


for(


int i =


0;i <= w;i++


)//數a[i]應儲存在下標為t[i]的位置 


vector<


int>


ans(len)


;for


(int i = len-


1;i >=


0;i--


)print


(ans,len);}


intmain()
字首和的使用優化保證了排序穩定

時間複雜度是o(n + w)，n是元素個數，w是最大最小值的差（也就是分塊個數）

#include


using


namespace std;


void


quicksort


(vector<


int>


&nums,


int l,


int r)


swap


(nums[fir]


, nums[l]);


//nums[last] = key;同理


quicksort


(nums, l ,fir)


;quicksort


(nums, fir +


1, r)


;//fir處元素已排好位置


}int


main()
平均時間複雜度是o(nlogn)，最差情況下為o(n²)（優化情況：三路快排，內省排序）

不穩定

#include


using


namespace std;


void


quicksort


(int arr,


int len)


quicksort


(arr,j)


;quicksort


(arr+k,len-k);}


intmain()


/* 本質是將陣列分成三部分


小於key || 等於key || 大於key


0 -- j j+1 -- i k -- len-1


利用隨機化排除重複元素堆積導致的時間複雜度公升高情況


這種寫法的partition還可用於尋找陣列中第k大元素（o(n)）


*/
#include


using


namespace std;


int t[


101]


, a[


101]


;void


merge


(int l,


int r)


for(


int i = l;i < r;i++


)//複製已排序好的組合進原陣列 


a[i]


= t[i];}


intmain()
最優，平均，最差時間複雜度都是o(nlogn)

需要o(n)的空間

穩定可用來求逆序對

#include


using


namespace std;


void


heapify


(int arr,


int st,


int en)


if(arr[root]


> arr[right]


)break


;else}}


void


hsort


(int arr,


int len)


}int


main()
最優，平均，最差時間複雜度都是o(nlogn)

不穩定

#include


using


namespace std;


const


int n =


100010


;int n;


//元素個數 


int w;


//最大最小差值，用於分桶


int a[n]


;//存數陣列


vector<


int>bucket[n]


;//桶


void


isort


(vector<


int>


& a)


a[j+1]


= key;}}


void


bucketsort()


w = max - min;


int size = w/n +1;


//桶大小 


for(


int i =


0;i < n;i++


) bucket[i]


.clear()


;//清桶 


for(


int i =


0;i < n;i++


)int p =0;


for(


int i =


0;i < n;i++)}


}int


main()
內部排序使用了插入排序保證了穩定性

在資料分布均勻時，時間複雜度為o(n)

最差情況的時間複雜度為o(n²)

排序演算法 插入 選擇 冒泡 快排 歸併

可以找一些帖子理解下幾類排序演算法或者聽下陳越姥姥在mooc上的資料結構 選擇類排序 交換類排序 歸併排序 基數排序 拓撲排序 從待排序的n個記錄中的第二個記錄開始，依次與前面的記錄比較並尋找插入的位置，每次外迴圈結束後，將當前的數插入到合適的位置。void sort insert int a,in...

常見排序演算法（冒泡 插入 選擇 遞迴 快排）

改進的話，可以加個標誌，當某次遍歷沒有交換，則說明陣列已有序，結束 void bubble sort int nums,int size return void insert sort int nums,int size else nums j 1 cur return void select so...

07 排序之冒泡 插入 選擇

排序演算法的執行效率 排序演算法的記憶體消耗 也就是空間複雜度，特別的，空間複雜度為o 1 的排序演算法也叫原地排序演算法 排序演算法的穩定性 如果待排序的序列中存在值相等的元素，經過排序之後，相等元素之間原有的先後順序不變。演算法 public static void sort int array...