经典排序算法分析实现

经典排序算法

冒泡排序

核心思想

1. 比较相邻二个元素，如果相邻的元素逆序就交换位置。

时间复杂度

1. 最好情况，要排序的数据已经是有序的了，我们只需要进行一次冒泡操作，就可以了，所以最好情况时间复杂度为O（n)
2. 最坏情况，要排序的数组刚好倒叙排列，我们需要进行n次冒泡排序操作，所以最坏情况时间复杂度为O（n^2)
3. 平均时间复杂度O（n^2)

比较次数

1. （n-1）+（n-2）+（n-3）+ …+1=n*(n-1)/2。

代码实现

	public static void bubbleSort(int[] arr){
        if (arr.length <= 1)return;
        for (int i = 0; i < arr.length - 1; i++) {
            //提前退出标志位
            boolean flag = false;
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            //没有数据交换，提前退出
            if (!flag)break;
        }
    }

插入排序

核心思想

1. 我们将数组中的数据分为二个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序，重复这个过程，直到未排序区间中元素为空，算法结束。

时间复杂度

1. 最好情况，如果要排序的数据已经是有序的，我们并不需要搬移任何数据，如果我们从尾到头在有序数据数组里面查找插入位置，每次只需要比较一个数据就能确定插入的位置。所以这种情况下，最好的时间复杂度为O（n）。
2. 如果数组是倒叙的，每次插入都相当于在数组的第一位置插入新的数据，所以需要移动大量的数据，所以最坏情况时间复杂度为O(n^2)
3. 平均时间复杂度O（n^2)

代码实现

	public static void insertSort(int[] arr){
        if (arr.length <= 1)return;
        for (int i = 1; i < arr.length; i++) {
            int value = arr[i];
            int j = i - 1;
            //查找要插入的位置并移动数据
            for (;j >= 0;j--){
                if (arr[j] > value){
                    arr[j + 1] = arr[j];
                }else {
                    break;
                }
            }
            arr[j+1] = value;
        }
    }

选择排序

核心思想

1. 选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。

时间复杂度

1. 选择排序的最好情况时间复杂度，最坏情况和平均情况和平均情况时间复杂度都为O(n^2)

代码实现

	public static void selectSort(int[] arr){
        if (arr.length <= 1)return;
        for (int i = 0; i < arr.length - 1; i++) {
            //查找最小值
            int minIndex = i;
            for (int j = i+1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]){
                    minIndex = j;
                }
            }
            //交换
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }

归并排序

核心思想

1. 如果要排序一个数组，我们先把数组从中间分为前后二部分，然后对前后二部分分别排序，再将排好序的二部分合并在一起，这样整个数组就都有序了。归并排序使用的就是分治思想。

时间复杂度

1. 归并排序的执行效率与要排序的原始数组的有序程度无关，所以其时间复杂度是非常稳定的，不管是最好情况，最坏情况，还是平均情况，时间复杂度都是O(nlogn)

代码实现

	public static void mergeSort(int[] arr){
        mergeSortInternally(arr,0,arr.length - 1);
    }

    private static void mergeSortInternally(int[] arr, int p, int r) {
        //递归终止条件
        if (p >= r)return;
        //取p到r之间的中间位置q
        int q = (p+r)/2;
        //分治递归
        mergeSortInternally(arr,p,q);
        mergeSortInternally(arr, q+1, r);
        //合并
        merge(arr,p,q,r);
    }

    private static void merge(int[] arr, int p, int q, int r) {
        int i = p;
        int j = q+1;
        int k = 0;
        //申请临时数组
        int[] tmp = new int[r-p+1];
        while (i <= q && j <= r){
            if (arr[i] <= arr[j]){
                tmp[k++] = arr[i++];
            }else {
                tmp[k++] = arr[j++];
            }
        }
        //判断那个子数组中有剩余数
        int start = i;
        int end = q;
        if (j <= r){
            start = j;
            end = r;
        }
        //将剩余的数据拷贝到临时数组
        while(start <= end){
            tmp[k++] = arr[start++];
        }
        //将临时数组中的数据拷贝到原数组
        for (int l = 0; l <= r - p; l++) {
           arr[p+l] = tmp[l];
        }
    }

快速排序

核心思想

1. 如果要排序数组中下标从 p 到 r 之间的一组数据，我们选择 p 到 r 之间的任意一个数据作为 pivot（分区点）。
   我们遍历 p 到 r 之间的数据，将小于 pivot 的放到左边，将大于 pivot 的放到右边，将 pivot 放到中间。经过这一步骤之后，数组 p 到 r 之间的数据就被分成了三个部分，前面 p 到 q-1 之间都是小于 pivot 的，中间是 pivot，后面的 q+1 到 r 之间是大于 pivot 的。根据分治、递归的处理思想，我们可以用递归排序下标从 p 到 q-1 之间的数据和下标从 q+1 到 r 之间的数据，直到区间缩小为 1，就说明所有的数据都有序了。

时间复杂度

1. 二种极端情况下的时间复杂度，一个是分区及其均衡（O(nlogn)),一个分区及其不均衡（O(n^2））

代码实现

    public static void quickSort(int[] arr){
        quickSortInternally(arr,0,arr.length - 1);
    }

    private static void quickSortInternally(int[] arr, int left, int right) {
        //递归终止条件
        if (left >= right)return;
        //确定分区点
        int q = partition(arr,left,right);
        quickSortInternally(arr, left, q - 1);
        quickSortInternally(arr, q + 1, right);
    }

    private static int partition(int[] arr, int left, int right) {
       int pivot = arr[right];
       int i = left;
        for (int j = left; j < right; j++) {
            if (arr[j] < pivot){
                if (i == j){
                    i++;
                }else {
                    int tmp = arr[i];
                    arr[i++] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
        int tmp = arr[i];
        arr[i] = arr[right];
        arr[right] = tmp;
        return i;
    }