有關數組的排序有冒泡排序、插入排序、選擇排序、快速排序、希爾排序、堆排序等。
冒泡排序
冒泡排序思想：
將數組中的元素兩兩進行比較，第一輪比較後，最大的元素放在數組的最大索引處。
冒泡排序原理：
- 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
- 對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
- 針對所有的元素重複以上的步驟，除了最後一個。
- 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。
冒泡排序舉例1：
分析：
代碼：
public class Demo5 {
public static void main(String[] args) {
int[] arr = {24, 65, 84, 53, 16};
System.out.println("未排序的數組" + Arrays.toString(arr));
// 數組按從小到大的順序排列
arraySort(arr);
System.out.println("經過冒泡排序之後的數組" + Arrays.toString(arr));
}
private static void arraySort(int[] arr) {
for (int j = 1; j <= arr.length - 1; j++) {
for (int i = 0; i < arr.length - j; i++) {
if (arr[i] > arr[i + 1]) {
int t = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = t;
}
}
}
}
}
冒泡排序舉例2：
public class Demo5 {
public static void main(String[] args) {
int[] arr = {24, 65, 84, 53, 16};
System.out.println("未排序的數組" + Arrays.toString(arr));
// 數組按從小到大的順序排列
arraySort(arr);
System.out.println("經過冒泡排序之後的數組" + Arrays.toString(arr));
}
private static void arraySort(int[] arr) {
for (int j = 0; j < arr.length - 1; j++) {
for (int i = 0; i < arr.length - j - 1; i++) {
if (arr[i] > arr[i + 1]) {
int t = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = t;
}
}
}
}
}
結果：
未排序的數組[24, 65, 84, 53, 16]
經過冒泡排序之後的數組[16, 24, 53, 65, 84]
選擇排序
選擇排序思想：
從0索引開始，依次和後面元素比較，小的往前放，第一次比較完畢，最小值出現在了最小索引處。
選擇排序是不穩定的排序。
選擇排序舉例：
分析：
代碼：
public class Demo6 {
public static void main(String[] args) {
int[] arr = {24, 65, 84, 53, 16};
System.out.println("未排序的數組爲：" + Arrays.toString(arr));
// 數組按從小到大的順序排列
arraySort(arr);
System.out.println("經過選擇排序之後的數組爲：" + Arrays.toString(arr));
}
private static void arraySort(int[] arr) {
for (int j = 0; j < arr.length - 1; j++) {
for (int i = j + 1; i < arr.length; i++) {
if (arr[j] > arr[i]) {
int t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
}
}
}
結果：
未排序的數組爲：[24, 65, 84, 53, 16]
經過選擇排序之後的數組爲：[16, 24, 53, 65, 84]
插入排序
插入排序思想：每次將後面一個元素，插入到之前得一個有序序列中，使之仍保持有序.
將數組索引0處的元素看成是一個有序列表，數組索引1開始的元素每一個與有序列表的元素進行比較，將該元素插入有序列表的某個位置，新列表仍然保持有序。
舉例：
分析：
代碼：
public class Demo7 {
public static void main(String[] args) {
int[] arr = {24, 65, 84, 53, 16};
System.out.println("未排序的數組爲：" + Arrays.toString(arr));
// 數組按從小到大的順序排列
arraySort(arr);
System.out.println("經過插入排序之後的數組爲：" + Arrays.toString(arr));
}
private static void arraySort(int[] arr) {
for (int i = 1; i <= arr.length-1; 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--;
}
}
}
}
結果：
未排序的數組爲：[24, 65, 84, 53, 16]
經過插入排序之後的數組爲：[16, 24, 53, 65, 84]
快速排序
快速排序的思想：
分治法，比大小，再分區。
- 從數組中取出一個數，作爲基準數。
- 分區：將比這個數大或等於的數全放到他的右邊，小於他的數全放到他的左邊。
- 再對左右區間重複第二步，直到各區間只有一個數。
舉例：
代碼：
快排工具類
public class QuickSortUtils {
private 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, j = end;
// 找基準數
int num = arr[i];
// 採用挖坑填數法。
while (i < j) {
// 從後向前找比基準數小的數
while (i < j && num < arr[j]) {
j--;
}
if (i < j) {
arr[i] = arr[j];
i++;
}
// 從前向後找比基準數大的數
while (i < j && num > arr[i]) {
i++;
}
if (i < j) {
arr[j] = arr[i];
j--;
}
}
arr[i] = num;
return i;
}
}
測試類：
public class Demo8 {
public static void main(String[] args) {
int[] arr = {24, 65, 84, 53, 16};
System.out.println("未排序的數組爲：" + Arrays.toString(arr));
// 數組按從小到大的順序排列
QuickSortUtils.quickSort(arr, 0, arr.length-1);
System.out.println("經過快速排序之後的數組爲：" + Arrays.toString(arr));
}
}
結果：
未排序的數組爲：[24, 65, 84, 53, 16]
經過快速排序之後的數組爲：[16, 24, 53, 65, 84]