排序算法笔记（Java）

package datastructure;

import java.util.Arrays;
import java.util.Scanner;

public class Sort {
    static int len; //声明全局变量，用于记录arr的长度
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String s[] = str.split(" ");
        int arr[] = new int[s.length];
        for (int i=0; i<s.length; i++) {
            arr[i] = Integer.parseInt(s[i]);
        }
        len = arr.length;
        System.out.println(Arrays.toString(arr));
//        bubbleSort(arr);
//        selectSort(arr);
//        insertSort(arr);
//        quickSort(arr, 0, arr.length-1);
//        shellSort(arr);
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 冒泡排序（稳定）
     *
     * 每次比较相邻元素，如果第一个比第二个大，则交换。
     * 对每一对相邻元素作同样工作，从第一对到最后一对。
     * 每轮之后最后的元素是最大值。
     *
     * 时间复杂度 O(n^2)
     * 空间复杂度 O(1)
     * @param arr
     * @return
     */
    public static int[] bubbleSort(int[] arr) {
        if (len == 0) {
            return arr;
        }
        for (int i=0; i<len-1; i++) {
            for (int j=0; j<len-1-i; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }

    /**
     * 选择排序（不稳定）
     *
     * 1、从第一个元素开始，该元素可以认为已经被排序（最小/最大）
     * 2、在未排序的元素序列中从前向后扫描，找比该元素（已排序）小的最小值
     * 3、如果找到，两者互换。
     * 4、以此类推，直到所有元素均排序完毕。
     *
     * 时间复杂度为 O(n^2)。
     * 空间复杂度 O(1)
     *
     * @param arr
     * @return
     */
    public static int[] selectSort(int[] arr) {
        if (len == 0) {
            return arr;
        }
        for (int i=0; i<len; i++) {
            int minIndex = i;
            for (int j=i; j<len; j++) {
                if (arr[j] < arr[minIndex])
                    minIndex = j;
            }
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
        return arr;
    }

    /**
     * 直接插入排序（稳定）
     * 1、从第一个元素开始，该元素可以认为已经被排序；
     * 2、取出下一个元素，在已经排序的元素序列中从后向前扫描；
     * 3、如果该元素（已排序）大于新元素，将该元素移到下一位置；
     * 4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
     * 5、将新元素插入到该位置后；
     * 6、重复步骤2~5。
     *
     * 时间复杂度 O(n^2)
     * 空间复杂度 O(1)
     * @param arr
     * @return
     */
    public static int[] insertSort(int[] arr) {
        if (len == 0) {
            return arr;
        }
        for (int i=0; i<len-1; i++) {
            for (int j=i+1; j>0; j--) {
                if (arr[j] < arr[j-1]) {
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
        }
        return arr;
    }

    /**
     * 希尔排序[缩小增量排序]（不稳定）
     * 将待排序数组按照步长gap进行分组，
     * 然后将每组的元素利用直接插入排序的方法进行排序；
     * 每次再将gap折半减小，循环上述操作；
     * 当gap=1时，利用直接插入，完成排序。
     *
     * 时间复杂度：O(nlogn)
     * 空间复杂度 O(1)
     * @param arr
     * @return
     */
    public static int[] shellSort(int[] arr) {
        if (len == 0) {
            return arr;
        }
        int temp, gap = len / 2;
        while (gap > 0) {
            for (int i=gap; i < len; i++) {
                temp = arr[i];
                int preIndex = i - gap;
                while (preIndex >= 0 && arr[preIndex] > temp) {
                    arr[preIndex + gap] = arr[preIndex];
                    preIndex -= gap;
                }
                arr[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        return arr;
    }

    /**
     * 快速排序（不稳定）
     * 【https://www.bilibili.com/video/BV1at411T75o】
     * 1、从数列中挑出一个元素，称为"基准"（pivot）
     * 2、重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面
     * 3、递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。
     *
     * 时间复杂度 O(nlogn)
     * 空间复杂度 O(logn)
     * @param arr
     * @param L
     * @param R
     */
    public static void quickSort(int[] arr, int L, int R) {
        if (L >= R) {
            return ;
        }
        int left = L;
        int right = R;
        int pivot = arr[left];
        while (left < right) {
            // 从后向前找到比pivot小的元素
            while (left<right && arr[right]>=pivot){
                right--;
            }
            arr[left] = arr[right];
            // 从前向后找到比pivot大的元素
            while (left<right && arr[left]<=pivot){
                left++;
            }
            arr[right] = arr[left];
        }
        // 放置基准值，准备分治递归快排
        arr[left] = pivot;
        quickSort(arr, L, right-1);
        quickSort(arr, right+1, R);
    }

    /**
     * 堆排序 （不稳定）
     *
     * 时间复杂度：O(nlogn)
     * 空间复杂度 O(1)
     * @param arr
     * @return
     */
    public static int[] heapSort(int[] arr) {
        if (len == 0) {
            return arr;
        }
        for (int i=len-1; i>0; i--) {
            buildMaxHeap(arr, i);
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
        }

        return arr;
    }

    /**
     * 建立最大堆
     * @param arr
     */
    public static void buildMaxHeap(int[] arr, int n) {
        int child;
        for (int i=(n-1)/2; i>=0; i--) {
            //左节点
            child = 2 * i + 1;
            //右节点存在且大于左节点,child变为右节点
            if (child !=n && arr[child] < arr[child+1]) {
                child++;
            }
            //交换父节点与左右子节点中的最大值
            if (arr[i] < arr[child]) {
                int temp = arr[i];
                arr[i] = arr[child];
                arr[child] = temp;
            }
        }
    }
}