数组排序算法

---

排序知识框架总览

提示：本篇文章只列出了部分排序算法

---

1.冒泡排序

时间复杂度：O（n²）
稳定性：稳定

相邻的两个数值比较大小，互换位置。

代码如下：

public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    arr[j] = arr[j] ^ arr[j + 1];
                    arr[j + 1] = arr[j] ^ arr[j + 1];
                    arr[j] = arr[j] ^ arr[j + 1];
                }
            }
        }
    }

注意：两变量交换值的写法通常使用第三变量暂存数值进行交换，此处未使用此方法而是使用了位运算符。(a^b^a=b) (a^1=各位取反) (a^0=a)

2.简单选择排序

时间复杂度：O（n²）
稳定性：不稳定

固定值与其他值依次比较大小，互换位置。

代码如下：

public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int pos = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[pos] > arr[j]) {
                    pos = j;
                }
            }
            if (pos != i) {
                arr[pos] = arr[pos] ^ arr[i];
                arr[i] = arr[pos] ^ arr[i];
                arr[pos] = arr[pos] ^ arr[i];
            }
        }
    }

---

3.直接插入排序

时间复杂度：O（n²）
稳定性：稳定

将一个记录插入到已经排好序的有序表中。

代码如下：

public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int j;
            int temp = arr[i];
            for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = temp;
        }
    }

---

4.希尔排序

时间复杂度：O（n^1.3）
稳定性：不稳定

又称“缩小增量排序”，属于直接插入排序的一种高效改进版本。

代码如下：

public static void shellSort(int[] arr) {
        for (int gap = arr.length / 2; gap >= 1; gap /= 2) {
            for (int i = gap; i < arr.length; i += gap) {
                int j;
                int temp = arr[i];
                for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap) {
                    arr[j + gap] = arr[j];
                }
                arr[j + gap] = temp;
            }
        }
    }

---

5.快速排序

时间复杂度：O（nlog₂n）
稳定性：不稳定

通过一趟排序将要排序的数据分割称独立的两部分，其中一部分的所有数据比另一部分的数据都要小，然后按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，依次达到整个数据变成有序序列。

代码如下：

public static void quickSort(int[] arr, int start, int end) {
        int pivot = arr[start];
        int i = start;
        int j = end;
        while (i < j) {
            while (i < j && arr[j] > pivot) {
                j--;
            }
            arr[i] = arr[j];
            i++;
            while (i < j && arr[i] < pivot) {
                i++;
            }
            arr[j] = arr[i];
            j--;
        }
        arr[i] = pivot;
        if (i - 1 > start) {
            quickSort(arr, start, i - 1);
        }
        if (j + 1 < end) {
            quickSort(arr, j + 1, end);
        }
    }

---

6.归并排序

时间复杂度：O（nlog₂n）
稳定性：稳定

将已有序的子序列合并，得到完全有序的子序列。

代码如下：

    public static void mergeSort(int[] arr, int low, int high) {
        if (low < high) {
            int mid = (low + high) >>> 1;
            mergeSort(arr, low, mid);
            mergeSort(arr, mid + 1, high);
            merge(arr, low, mid, high);
        }
    }

    public static void merge(int[] arr, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int k = 0;
        int i = low;
        int j = mid + 1;
        while (i <= mid && j <= high) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= high) {
            temp[k++] = arr[j++];
        }
        k = 0;
        while (low <= high) {
            arr[low++] = temp[k++];
        }
        /*for (int l = 0; l < temp.length; l++) {
            arr[l+low] = temp[l];
        }*/
    }

---

口诀

选泡插
快归堆希桶计基
恩方恩老恩一三
对恩加K恩乘K
不稳稳稳不稳稳
不稳不稳稳稳稳

---

总结

以上就是今天要讲的内容，本文仅仅简单介绍了几种排序算法，希望与大家共同学习，共同进步。