氣泡排序
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {1, 0, 2, 3, 4};
int[] sort = bubbleSort(arr);
for (int item : sort) {
System.out.println(item);
}
}
/**
* 從後往前，不斷向前比較，小的向前面浮起來（交換）
* 如果發現一趟排序沒有交換，那麼flag=false，程式就提前退出了
* 時間複雜度O(n^2)
*
* @param arr 需要排序的陣列
* @return 返回排序後的陣列
*/
private static int[] bubbleSort(int[] arr) {
boolean flag = true;
for (int i = 0; i < arr.length && flag; i++) {
flag = false;
for (int j = arr.length - 1; j > i; j--) {
if (arr[j] < arr[j - 1]) {
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
flag = true;
}
}
}
return arr;
}
}
複製程式碼選擇排序
public class SelectSort {
public static void main(String[] args) {
int[] arr = {1, 0, 2, 3, 4};
int[] sort = selectSort(arr);
for (int item : sort) {
System.out.println(item);
}
}
/**
* 選擇排序的思想是，先假設一個為最小，然後用剩下的元素去比較
* 如果發現有比假設值小的，先把下標記錄下來，最後再進行交換
* 時間複雜度O(n^2)
*
* @param arr 需要排序的陣列
* @return 返回排序後的陣列
*/
private static int[] selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;//先選擇一個最小的，然後用其他去跟這個比較，直到找到最小的那個為止
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
//先記錄下來，最後再交換
min = j;
}
}
if (min != i) {
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
return arr;
}
}
複製程式碼插入排序
public class InsertSort {
public static void main(String[] args) {
int[] arr = {1, 0, 2, 3, 4};
int[] sort = insertSort(arr);
for (int item : sort) {
System.out.println(item);
}
}
/**
* 基本思想：在要排序的一組數中，假設前面n-1個數已經是排好順序的，
* 把第n個數插到前面的有序數中，使得這n個數也是排好順序的。如此反覆迴圈。
* 時間複雜度O(n^2)
*
* @param arr 需要排序的陣列
* @return 返回排序後的陣列
*/
private static int[] insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
if (arr[i] < arr[i - 1]) {
//假設下標i前面的數已經排好序，把當前下標i的元素插入到前面
//具體插入位置：如果前面的元素比下標i的元素小，不斷向前覆蓋
//最後把下標i的元素插入到正確位置
int temp = arr[i];
int j = i - 1;
for (; j >= 0 && arr[j] > temp; j--) {
arr[j + 1] = arr[j];
}
arr[j + 1] = temp;
}
}
return arr;
}
}
複製程式碼希爾排序
public class Shell {
public static void main(String[] args) {
int[] arr = {1, 0, 2, 3, 4};
int[] sort = shellSort(arr);
for (int item : sort) {
System.out.println(item);
}
}
/**
* 希爾排序，元素的分組跳躍式排序
* 時間複雜度O(n * log(n))
*
* @param arr 需要排序的陣列
* @return 返回排序後的陣列
*/
private static int[] shellSort(int[] arr) {
int inc = arr.length;
do {
inc = inc / 3 + 1;
for (int i = inc; i < arr.length; i++) {
if (arr[i] < arr[i - inc]) {
int temp = arr[i];
int j = i - inc;
for (; j >= 0 && arr[j] > temp; j = j - inc) {
arr[j + inc] = arr[j];
}
arr[j + inc] = temp;
}
}
} while (inc > 1);
return arr;
}
}
複製程式碼堆排序
public class HeapSort {
public static void main(String[] args) {
//第一個元素捨棄，因為二叉樹的元素下標要從1開始
int[] arr = {-1, 1, 0, 2, 3, 4};
int[] sort = heapSort(arr);
for (int item : sort) {
System.out.println(item);
}
}
/**
* 堆排序是通過不斷構造大頂堆
* 時間複雜度O(n * log(n))
*
* @param arr 需要排序的陣列
* @return 返回排序後的陣列
*/
private static int[] heapSort(int[] arr) {
int len = arr.length - 1;
//從下往上，從右往左構建大頂堆
for (int i = len / 2; i > 0; i--) {
adjust(arr, i, len);
}
for (int i = len; i > 1; i--) {
//交換最後一個元素與大頂堆的根結點
int temp = arr[i];
arr[i] = arr[1];
arr[1] = temp;
adjust(arr, 1, i - 1);
}
return arr;
}
private static void adjust(int[] arr, int s, int m) {
int temp = arr[s];
for (int i = s * 2; i <= m; i = i * 2) {
//判斷左右子結點哪個大
if (i < m && arr[i] < arr[i + 1]) {
i++;
}
//如果當前的雙親結點是最大的那個，那麼不用繼續調整
if (temp >= arr[i]) {
break;
} else {
//把當前左右結點中的最大值賦值給雙親結點
arr[s] = arr[i];
//以當前最大結點為雙親結點，繼續下一次迴圈，知道找到
//temp應該存放的位置為止
s = i;
}
}
//找到temp應該存放的位置
arr[s] = temp;
}
}
複製程式碼歸併排序
public class MergeSort {
public static void main(String[] args) {
int[] arr = {1, 0, 2, 3, 4};
mergeSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
/**
* 歸併排序
* 時間複雜度O(n * log(n))
*
* @return 返回排序後的陣列
*/
private static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
//陣列拆分
int center = (left + right) / 2;
mergeSort(arr, left, center);
mergeSort(arr, center + 1, right);
//拆到不能再拆的時候，開始合併
merge(arr, left, right);
}
}
private static void merge(int[] arr, int left, int right) {
int[] temp = new int[arr.length];
int mid = (left + right) / 2;
int i = left;
int j = mid;
int k = left;
//逐一比較大小，把小的存到臨時陣列裡面
while (i < mid && j < right) {
if (arr[i] < arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
//把剩下的元素寫進去
while (i < mid) {
temp[k++] = arr[i++];
}
while (j < right) {
temp[k++] = arr[j++];
}
//把臨時陣列的內容拷貝回去
int l = left;
while (l < right) {
arr[l] = temp[l];
l++;
}
}
}
複製程式碼快速排序
public class QuickSort {
public static void main(String[] args) {
int[] arr = {1, 0, 2, 3, 4};
quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
/**
* 快速排序
* 時間複雜度O(n * log(n))
* 優化方式：1三數取中 2優化不必要的交換 3小陣列的方案 4尾遞迴優化
*
* @return 返回排序後的陣列
*/
private static void quickSort(int[] arr, int low, int hight) {
if (low < hight) {
//計算基準點
int pivot = partition(arr, low, hight);
//分別對基準點左右兩邊進行遞迴
quickSort(arr, low, pivot - 1);
quickSort(arr, pivot + 1, hight);
}
}
private static int partition(int[] arr, int low, int hight) {
int pivotKey = arr[low];
while (low < hight) {
while (low < hight && arr[hight] >= pivotKey) {
hight--;
}
swap(arr, low, hight);
while (low < hight && arr[low] <= pivotKey) {
low++;
}
swap(arr, low, hight);
}
return low;
}
private static void swap(int[] arr, int i1, int i2) {
int temp = arr[i1];
arr[i1] = arr[i2];
arr[i2] = temp;
}
}
複製程式碼如果覺得我的文字對你有所幫助的話，歡迎關注我的公眾號：
我的群歡迎大家進來探討各種技術與非技術的話題，有興趣的朋友們加我私人微信huannan88，我拉你進群交（♂）流（♀）。