算法分類
比較排序：在排序的最終結果裏，元素之間的次序依賴於他們之間的比較，每個數必須和其他數進行比較，才能確定自己的位置。
-
優勢：適用於一切需要排序的情況。不在乎數據的分佈，適用於各種規模的數據
-
冒泡排序、快速排序、插入排序、希爾排序 、堆排序、選擇排序、歸併排序。
在冒泡排序之類的排序中，問題規模爲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;
}
}//加入Java開發交流君樣：756584822一起吹水聊天
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;
}//加入Java開發交流君樣：756584822一起吹水聊天
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;
}
//加入Java開發交流君樣：756584822一起吹水聊天
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];
}
}//加入Java開發交流君樣：756584822一起吹水聊天
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>());
}//加入Java開發交流君樣：756584822一起吹水聊天
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 ++;
}//加入Java開發交流君樣：756584822一起吹水聊天
//創建桶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();//清除桶中的數據
}
}//加入Java開發交流君樣：756584822一起吹水聊天
return array;
}
