Java實現十種經典排序演算法
演算法分類
-
比較排序:在排序的最終結果裡,元素之間的次序依賴於他們之間的比較,每個數必須和其他數進行比較,才能確定自己的位置。
優勢:適用於一切需要排序的情況。不在乎資料的分佈,適用於各種規模的資料
氣泡排序、快速排序、插入排序、希爾排序 、堆排序、選擇排序、歸併排序。
在氣泡排序之類的排序中,問題規模為n,又因為需要比較n次,所以平均時間複雜度為O(n²)。在歸併排序、快速排序之類的排序中,問題規模通過分治法消減為logN次,所以平均時間複雜度為O(nlogn)。
-
非比較排序:只要確定每個元素之前的已有的元素個數即可,所有一次遍歷即可解決。時間複雜度為O(n)。
計數排序、基數排序、桶排序。
非比較排序的時間複雜度低,但是需要佔用空間來確定唯一的位置。
遞迴factorial
方法內部呼叫方法本身
⚠️遞迴的層級太深容易造成棧記憶體溢位stackOverFlowError
氣泡排序
一次比較相鄰的兩個元素,如果第一個比第二個大就交換它們兩個。
從第一對到結尾的最後一對,重複比較。
重複前面兩個步驟(每次都能找到一輪中的最大值)。
演算法分析:
最佳情況:T(n) = O(n) 最差情況:T(n) = O(n²) 平均情況:T(n) = O(n²)
public static int[] bubbleSort(int[] array){ if(array.length > 0){ for(int i=0; i<array.length; i++){ for(int j=0; j<array.length-1-i; j++){ if(array[j] > array[j+1]){ int temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; } } } } return array; }
選擇排序
表現最穩定的排序演算法之一,什麼資料進去都是O(n²)的時間複雜度。
在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然後,再從剩餘未排序元素中繼續尋找最小(大)元素,然後放到已排序序列的末尾。以此類推,直到所有元素均排序完畢。
第i趟排序(i=1,2,3…n-1)開始時,當前有序區和無序區分別為R[1..i-1]和R(i..n)。該趟排序從當前無序區中-選出關鍵字最小的記錄 R[k],將它與無序區的第1個記錄R交換,使R[1..i]和R[i+1..n)分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區
最佳情況:T(n) = O(n²) 最差情況:T(n) = O(n²) 平均情況:T(n) = O(n²)
public static int[] selectionSort(int[] array){
if(array.length > 0){
for(int i=0; i<array.length; i++){
int minIndex = i;
for(int j=i; j<array.length; j++){
if(array[j] < array[minIndex]){
mindex = j;
}
}
if(minIndex != i){
int temp = array[i];
array[i] = array[minIndex];
array[minIndex] = temp;
}
}
}
return array;
}
插入排序
在已排序序列中從後向前掃描,找到未排序資料的相應位置並插入。
通常採用in-place排序,即只需用到O(1)的額外空間的排序。
最佳情況:T(n) = O(n) 最差情況:T(n) = O(n²) 平均情況:T(n) = O(n²)
public static int[] insertSort(int[] array){
if(array.length > 0){
for(int i=0; i<array.length; i++){
int current = array[i+1];
int index = i;
while(index >= 0 && current < array[index]){
array[index+1] = array[index];
index--;
}
array[index+1] = current;
}
}
return array;
}
希爾排序
也稱為縮小增量排序,優先比較距離較遠的元素。
設定增量gap,按增量分組,對每組進行插入排序,隨著增量減少,每組元素越來越多,當增量到1時,所有資料被分為1組。
最佳:T(n) = O(nlog2n) 最壞:T(n) = O(nlog2n) 平均:T(n) = O(nlog2n)
public static int[] shellSort(int[] array){
if(array.length > 0){
int len = array.length;
int gap = len/2;
while(gap > 0){
for(int i=gap; i<len; i++){
int current = array[i];
int index = i - gap;
while(index >= 0 && current < array[index]){
array[index+gap] = array[index];
index -= gap;
}
array[index+gap] = current;
}
gap /= 2;
}
}
return array;
}
歸併排序
始終都是O(nlogn)的時間複雜度,代價是需要額外的空間
採用分治法Divide and Conquer
先使每個子序列有序,再使子序列段間有序。
最佳情況:T(n) = O(n) 最差情況:T(n) = O(nlogn) 平均情況:T(n) = O(nlogn)
public static int[] mergeSort(int[] array){
if(array.length < 2){
return array;
}
int mid = array.length / 2 ;
int[] left = Arrays.copyOfRange(array, 0, mid);
int[] right = Arrays.coptOfRange(array, mid, array.length);
return merge(mergeSort(left), mergeSort(right));
}
public static merge(int[] left, int[] right){
int[] result = new int[left.length + right.length];
for(int index = 0, i=0, j=0; index<result.length; index++){
if(i >= left.length){
result[index] = right[j];
j++;
}else if(j >= right.length){
result[index] = left[i];
i++;
}else if(left[i] > right[j]){
result[index] = right[j];
j++;
}else{
result[index] = left[i];
i++;
}
}
return result;
}
快速排序
通過一趟排序將待排記錄分隔成獨立的兩部分,其中一部分均比另一部分的小。
挑出一個元素稱為基準privot
最佳情況:T(n) = O(nlogn) 最差情況:T(n) = O(n2) 平均情況:T(n) = O(nlogn)
public static void quickSort(int[] array, int low, int hight){
if(low < hight){
int privotpos = partition(array, low, hight);
quickSort(array, low, privotpos-1);
quickSort(array, privotpos+1, hight);
}
}
/*
partition:
選第一個元素為基準
從hight往前看,遇到第一個比privot小的數,就放到privot的位置上
換從low往後看,遇到第一個比privot大的數,放到剛才hight的位置
再換hight...
最後空出來的位置放privot
*/
public static int partition(int[] array, int low, int hight){
int privot = array[low];
while(low < hight){
while(low < hight && array[hight] >= privot){
hight--;
}
array[low] = array[hight];
while(low < hight && array[low] <= privot){
low++;
}
array[hight] = array[low];
}
array[low] = privot;
return low;
}
堆排序
堆的定義:n個元素的序列{k1,k2,ki,…,kn}當且僅當滿足下關係時,稱之為堆。
(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4…n/2)
堆是一顆完全二叉樹,堆雖然是一顆樹,但是通常存放在一個數組中,父節點和孩子節點的父子關係通過陣列下標來確定。
一個節點在陣列的索引怎麼計算父節點及左右孩子節點的索引:
public int left(int i){
return (i+1)*2-1;
}
public int right(int i){
return (i+1)*2;
}
public int parent(int i){
if(i == 0){
return -1;
}
return (i-1)/2;
}
建立一個堆
把堆首和堆尾互換
堆的尺寸減少1,重新調整堆
重複2-3步,直至減小到1
最佳情況:T(n) = O(nlogn) 最差情況:T(n) = O(nlogn) 平均情況:T(n) = O(nlogn)
public static int[] heapSort(int[] array){
int len = array.length;
for(int i=(len/2 -1); i>=0; i--){
heapAdjust(array, i, len);
}
//堆頂元素和最後一個元素交換,並重新調整堆
for(int i=len-1; i>0; i--){
int temp = array[i];
array[i] = array[0];
array[0] = temp;
heapAdjust(array, 0, i);
}
return array;
}
public static void headAdjust(int[] array, int index, int length){
int max = index;
int lchild = 2 * index;//左子節點
int rchild = 2 * index + 1;//右子節點
if(length > lchild && array[max] < array[lchild]){
max = lchild;
}
if(length > rchild && array[max] < array[rchild]){
max = rchild;
}
//如果該節點比左右節點小,就換位置後調整堆
if(max != index){
int temp = array[index];
array[index] = array[max];
array[max] = temp;
heapAdjust(array, max, length);
}
}
計數排序
核心:將輸入的資料值轉化為鍵,儲存在額外的資料空間中
找出最大值和最小值
統計每個值為i的元素出現的次數,存入陣列C的第i項
反向填充目標陣列:將元素i放在新陣列,每放一個就將C[i]減去1
分析:當輸入的元素是n個 0到k之間的整數,執行時間是O(n+k),計數排序不是比較排序,排序的速度快於任何比較排序演算法。對於資料範圍很大陣列,需要大量時間和記憶體。
最佳情況:T(n) = O(n+k) 最差情況:T(n) = O(n+k) 平均情況:T(n) = O(n+k)
public static int[] countingSort(int[] array){
if(array.length == 0){
return array;
}
int bias = 0;
int min = array[0];
int max = array[0];
//找到最大值 最小值
for(int i=0; i < array.length; i++){
if(array[i] > max){
max = array[i];
}
if(array[i] < min){
min = array[i];
}
}
bias = 0 - min;//偏差
int[] bucket = new int[max - min + 1];
Arrays.fill(bucket, 0);//新建立一個數組,初始化為0
for(int i=0; i<array.length; i++){
bucket[array[i] + bias] += i;
}
int index = 0;
for(int i=0; i<bucket.length; i++){
int len = bucket[i];
while(len > 0){
array[index] = i - bias;
len--;
index++;
}
}
return array;
}
桶排序
將資料分到有限數量的桶中,每個桶再分別排序(可以用別的排序)
找到待排序的最大值和最小值
桶的個數:(max-min)/arr.length +1,數值和桶的對應關係:(arr[i]-min)/arr.length
桶中每個元素都是一個連結串列/陣列
每個桶的元素進行排序
最佳情況:T(n) = O(n+k) 最差情況:T(n) = O(n+k) 平均情況:T(n) = O(n2)
public static ArrayList<ArrayList<Integer>> bucketSort(int[] array){
int max = array[0];
int min = array[0];
for(int value : arr){
max = Math.max(value, max);
min = Math.min(value, min);
}
int bucketNumber = (max - min)/array.length + 1;//定義桶的個數
ArrayList<ArrayList<Integer>> result = new ArrayList<>();//建立一個桶
for(int i=0; i<bucketNumber; i++){
result.add(new ArrayList<Integer>());
}
for(int value : array){//把元素放入桶中
result.get((value - min)/array.length).add(value);
}
for(int i=0; i<result.size(); i++){
if(result.get(i).size() > 0){
insertSort(result.get(i));//用插入排序對每個桶中的元素排序
}
}
return result;
}
基數排序
非比較的排序演算法,從最低位開始對每一位排序。基數排序基於分別排序,分別收集,所以是穩定的。
低位優先
確定遍歷位數
按照個位數放入相應的桶中
從桶中將元素返回,再次遍歷,按照十位按序存入...
最佳情況:T(n) = O(n * k) 最差情況:T(n) = O(n * k) 平均情況:T(n) = O(n * k) k是陣列中最大數的位數
public static int[] radixSort(int[] array){
if(array == null || array.lrngth < 2){
return array;
}
//先算出最大數的位數
int max = array[0];
for(int i=0; i<array.length; i++){
max = Math.max(max, array[i]);
}
int maxdigit = 0;
while(max != 0){
max = max / 10;
maxDigit ++;
}
//建立桶0~9
int mod = 10, div = 1;
ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
for(int i=0; i<10; i++){
bucketList.add(new ArrayList<Integer>());
}
for(int i=0; i<maxDigit; i++, mod*=10, div*=10){
for(int j=0; j<array.length; j++){
int num = (array[j] % mod) / div;
bucketList.get(num).add(array[j]);
}
int index = 0;
for(int j=0; j<bucketList.size(); j++){
for(int k=0; k<bucketList.get(j).size(); k++){
array[index++] = bucketList.get(j).get(k);//從桶中取出來進行下一次排序
}
bucketList.get(j).clear();//清除桶中的資料
}
}
return array;
}