1、基數排序
1、基數排序：又稱桶子排序，它是通過鍵值的各個位的值，將要排序的元素fenp至某些“桶”中，達到排序的作用。基數排序法是屬於穩定性的排序，基數排序法的是效率高的穩定性排序法。基數排序是使用空間換時間的經典算法。
2、基排序基本思想：將所有待排序數補全成統一長度的數，數位短的前面用0補齊，然後從低位開始，依次排序，最後就會得到一個有序序列。
下面畫一張圖，讓大家更直觀得看到基數排序是怎麼實現的。
下面我們代碼實現一波：
public class RadixSort {
public static void main(String[] args) {
int[] arr = {4,3,76,4,332,12,45,6,5,3,234};
radixSort(arr);
}
public static void radixSort(int[] arr){
//1、計算出數組中最大的數的位數
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max){
max = arr[i];
}
}
//測試找出最大值是否正確
// System.out.println("max= "+ max);
//2、計算出最大數的位數
int maxLength = (max + "").length();
//3、創建十個桶，用二維數組表示，
int[][] bucket = new int[10][arr.length];
//4、定義一個一維數組，存放每個桶中每次放入的數據
int[] bucketElems = new int[10];
//5、將無序序列中的元素依次拿出，依次計算出個位，十位，百位的數，依次放入對應的桶中
for (int i = 0 ,n =1; i <maxLength ; i++ ,n *= 10) {
for (int j = 0; j < arr.length; j++) {
//取出對應的個位，十位，百位數
int elems = arr[j] / n % 10;
//放入對應的桶中
bucket[elems][bucketElems[elems]] = arr[j];
bucketElems[elems]++;
}
int index = 0;
for (int j = 0; j < bucketElems.length; j++) {
if (bucketElems[j] != 0){
for (int k = 0; k < bucketElems[j]; k++) {
//取出元素放入arr數組
arr[index++] = bucket[j][k];
}
}
//沒一輪過後需要將其置爲空，爲下一輪準備
bucketElems[j] = 0;
}
System.out.println("第" + (i + 1) + "輪基數排序後的結果爲：" + Arrays.toString(arr));
}
}
}
2、歸併排序
1、歸併排序：歸並排序是利用歸併的思想實現的排序方法，該排序算法採用經典的分治策略。將問題分成一些小的問題然後遞歸求解，然後將分的階段得到的各答案"修補"在一起完成排序。
下面畫一張圖帶你理解歸併思想：
代碼演示：
public class test5 {
public static void main(String[] args) {
int arr[] = {4, 6, 76, 32, 45, 7, 9, 1};
int temp[] = new int[arr.length];
mergeSort(arr, 0, arr.length - 1, temp);
System.out.println(Arrays.toString(arr));
}
//編寫分階段的方法
public static void mergeSort(int[] arr, int left, int right, int[] temp) {
if (left < right) {
int mid = (right + left) / 2;
//向左遞歸切分
mergeSort(arr, left, mid, temp);
//向右遞歸切分
mergeSort(arr, mid + 1, right, temp);
//合
merge(arr, left, right, mid, temp);
}
}
//編寫合階段的方法
/**
* @param arr 待排序數組
* @param left 左邊有序序列索引
* @param right 右邊有序序列索引
* @param temp 中轉數組
*/
public static void merge(int[] arr, int left, int right, int mid, int[] temp) {
int i = left;
int j = mid + 1;
int t = 0;
//把分完的倆個數組按照比較將小的數優先放到temp數組中
while (i <= mid && j <= right) {
if (arr[i] < arr[j]) {
temp[t] = arr[i];
i += 1;
t += 1;
} else {
temp[t] = arr[j];
j += 1;
t += 1;
}
}
//把剩餘的數依次加入temp數組
while (i <= mid) {
temp[t] = arr[i];
i += 1;
t += 1;
}
while (j <= right) {
temp[t] = arr[j];
j += 1;
t += 1;
}
System.out.println("排序之後的結果爲" + Arrays.toString(temp));
//3.把temp數組的元素拷貝到temp
t = 0;
int tempLeft = left;
System.out.println("templeft" + tempLeft + " " + "right" + right);
while (tempLeft <= right) {
arr[tempLeft] = temp[t];
t += 1;
tempLeft += 1;
}
}
}
3、希爾排序
1、希爾排序：希爾排序也是一種插入排序，它是簡單插入排序經過改進之後的一個更高效的版本，也稱爲縮小增量排序。
2、希爾排序思想：希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；每一輪根據結算逐漸減少增量，每組包含的關鍵詞越來越多，當增量減至1時，整個數組恰被分成一組，算法便終止。
public class shellSort {
public static void main(String[] args) {
int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
shellSort(arr);
}
//整合希爾排序
public static void shellSort(int[] arr) {
int temp = 0;
int count = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//希爾排序第一輪。是將十個數據分成了五組
for (int i = gap; i < arr.length; i++) {
//遍歷各組中所有的元素（共5組，每組2個元素）步長爲5
for (int j = i - gap; j >= 0; j = j - gap) {
//如果當前元素大於加上步長的那個元素，說明需要交換
if (arr[j] > arr[j + gap]) {
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
System.out.println("希爾排序第" + (++count) + "次：" + Arrays.toString(arr));
}
}
4、堆排序
1、堆排序：堆排序是利用堆這種數據結構而設計的一種排序算法，堆排序是一種選擇排序，它的最壞，最好，平均時間複雜度均爲O(nlogn)，它也是不穩定排序。
2、堆：堆是具有以下性質的完全二叉樹：每個結點的值都大於或等於其左右孩子結點的值，稱爲大頂堆。每個結點的值都小於或等於其左右孩子結點的值，稱爲小頂堆。一般升序採用大頂堆，降序採用小頂堆 。
3、堆排序思想：將待排序的數列先構成一個大頂堆或者小頂堆，此時二叉樹的的根節點是整個數列的最大值/最小值，將根節點和二叉樹末尾節點進行交換，重複對剩餘節點構造大頂堆/小頂堆就可以得到一個有序序列。
4、注意：堆排序中沒有構建二叉樹，而是以循序存儲二叉樹的方式來完成堆數組的操作。
public class HeapSort {
public static void main(String[] args) {
int[] arr = {4, 6, 8, 5, 9, 42, 4, 5, 202, 342342, 2, 45, 4, 23, 234, 5, 3, 2, 42};
heapSort(arr);
}
//堆排序方法：
public static void heapSort(int arr[]) {
int temp = 0;
System.out.println("堆排序！");
//完成最終代碼
//1、將無序序列構建成一個堆，根據升序降序需求選擇大頂堆或小頂堆
for (int i = arr.length / 2 - 1; i >= 0; i--) {//i非葉子節點
adjustHeap(arr, i, arr.length);
}
//2、將堆頂元素與末尾元素交換，將最大元素“沉”到數組末端
for (int j = arr.length - 1; j > 0; j--) {
//交換
temp = arr[j];
arr[j] = arr[0];//最大值和j交換
arr[0] = temp;
adjustHeap(arr, 0, j);
}
System.out.println(Arrays.toString(arr));
}
//將一個數組（二叉樹）調整成一個大頂堆
/**
* @param i : 表示非葉子節點在數組中的索引
* @param length : 表示對多少個元素繼續進行調整，length逐漸減少
*/
public static void adjustHeap(int[] arr, int i, int length) {
int temp = arr[i];//先取出當前元素的值，保存爲臨時變量
//開始調整
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
if (k + 1 < length && arr[k] < arr[k + 1]) {//當左子節點的值小於右子節點
k++;//指向右子節點
}
if (arr[k] > temp) {
arr[i] = arr[k];//把大的節點放到父結點位置上
i = k;//i指向k，繼續循環比較
} else {
break;
}
//for循環結束後，我們已經將以i爲父結點的樹的最大值放在了最頂部
arr[i] = temp;//把temp值放到調整後的位置
}
}
}