一：冒泡排序
public class demo3 {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
for (int j = 0; j < arr.length - 1; j++) {
for (int i = 0; i < arr.length - 1 - j; i++) {
if (arr[i] > arr[i + 1]) {
int t = arr[i + 1];
arr[i + 1] = arr[i];
arr[i] = t;
}
}
}
String string = Arrays.toString(arr);
System.out.println(string);
}
}
運行結果：
[13, 24, 57, 69, 80]
Process finished with exit code 0
二：選擇排序
public class demo3 {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
for (int index = 0; index < arr.length - 1; index++) {
for (int i = 1 + index; i < arr.length; i++) {
if (arr[index] > arr[i]) {
int t = arr[index];
arr[index] = arr[i];
arr[i] = t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
運行結果：
[13, 24, 57, 69, 80]
Process finished with exit code 0
三：快速排序
思想：
挖坑填數
1.將基準數挖出形成第一個坑。
2.由後向前找比他小的數，找到後挖出此數填到前一個坑中。
3.由前向後找比他大或等於的數，找到後也挖出此數填到前一個坑中。
再重複執行2，3兩步驟
public class QuickSortUtils {
public static void quickSort(int[] arr, int start, int end) {
if (start < end) {
//找到分左右兩半的中間索引
int index = getIndex(arr, start, end);//挖坑填數
//對左右兩區進行遞歸調用
quickSort(arr, start, index - 1); //對左半變部分進行遞歸
quickSort(arr, index + 1, end);//對右半部分進行遞歸
}
}
private static int getIndex(int[] arr, int start, int end) {
int i = start;
int j = end;
//找一個基準數
int x = arr[i];
while (i < j) {
// 2. 由後向前找比他小的數，找到後挖出此數填到前一個坑中。
while (i < j && arr[j] >= x) { //如果 這個數比基準數大，讓索引倒退
j--;
}
if (i < j) {
arr[i] = arr[j]; //把這個數填到上一個坑中
i++; //順便讓 i 遞增一下
}
//3由前向後找比他大或等於的數，找到後也挖出此數填到前一個坑中。
while (i < j && arr[i] < x) { //如果這個數比基準數小，就讓這個索引往前跑
i++;
}
if (i < j) {
arr[j] = arr[i]; //填到上一個坑
j--; //順便讓 j 遞減一下
}
}
//等上述完畢之後，把基準數填到最後一個坑位裏
arr[i] = x;
return i;
}
}
public class Test {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
QuickSortUtils.quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
}
運行結果：
[13, 24, 57, 69, 80]
Process finished with exit code 0
四：直接插入排序
public class demo4 {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
for (int i = 1; i < arr.length;i++) {
int j = i;
while (j > 0 && arr[j] < arr[j - 1]) {
int t = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = t;
j--;
}
}
System.out.println(Arrays.toString(arr));
}
}
運行結果：
[13, 24, 57, 69, 80]
Process finished with exit code 0
五：希爾排序
希爾排序嚴格來說是基於插入排序的思想，又被稱爲縮小增量排序。
具體流程如下：
1、將包含n個元素的數組，分成n/2個數組序列，第一個數據和第n/2+1個數據爲一對...
2、對每對數據進行比較和交換，排好順序；
3、然後分成n/4個數組序列，再次排序；
4、不斷重複以上過程，隨着序列減少並直至爲1，排序完成。
假如有初始數據：25 11 45 26 12 78。
1、第一輪排序，將該數組分成 6/2=3 個數組序列，第1個數據和第4個數據爲一對，第2個數據和第5個數據爲一對，第3個數據和第6個數據爲一對，每對數據進行比較排序，排序後順序爲：[25, 11, 45, 26,12, 78]。
2、第二輪排序，將上輪排序後的數組分成6/4=1個數組序列，此時逐個對數據比較，按照插入排序對該數組進行排序，排序後的順序爲：[11, 12, 25, 26, 45, 78]
代碼實現：
public class demo7{
public static void main(String[] args) {
int[] arr= {25,11,45,26,12,78};
for (int r = arr.length / 2; r >= 1; r = r / 2) {
for (int i = r; i < arr.length; i++) {
int tmp;
int j;
tmp = arr[i];
j = i - r;
// 一輪排序
while (j >= 0 && tmp < arr[j]) {
arr[j + r] = arr[j];
j -= r;
}
arr[j + r] = tmp;
}
}
System.out.println(Arrays.toString(arr));
}
運行結果：
[11, 12, 25, 26, 45, 78]
Process finished with exit code 0