基础排序算法 java 实现（冒泡、选择、插入、快排、归并、堆排）

package demo;

import java.util.Arrays;

public class SortUtil {
    private static void printArr(int[] arr) {
        System.out.println(Arrays.toString(arr));
    }

    private static void checkSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                throw new RuntimeException("Sort Error!");
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // 本机测试
    public static void main(String[] args) {
//        int[] arr = {4, 3, 5};

        int[] arr = new int[50000 * 100];
        java.util.Random random = new java.util.Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(arr.length);
        }

//        System.out.println("排序前：");
//        printArr(arr);

        long s = System.currentTimeMillis();

//        bubbleSort(arr);// 50000 数据 5000+ ms
//        selectSort(arr);// 50000 数据 1700+ ms
//        insertSort(arr);// 50000 数据 360+ ms

        quickSort(arr, 0, arr.length - 1);// 50000 * 100 数据 770 ms

//        mergeSort(arr);// 50000 * 100 数据 1300 ms
//        mergeSort(arr, 0, arr.length - 1);// 50000 * 100 数据 1300 ms

//        heapSort(arr);// 50000 * 100 数据 1650 ms

        long e = System.currentTimeMillis();
        System.out.println("耗时：" + (e - s));

        checkSort(arr);
        System.out.println("排序正确！");

//        System.out.println("排序后：");
//        printArr(arr);
    }

    private static void bubbleSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) { //要放置正确元素的目标位置，最后一个不用放
            for (int j = len - 1; j > i; j--) { // 从后往前，把最小（大）的挪动到目标位置
                if (arr[j] < arr[j - 1]) { // 后面的大于前面
                    swap(arr, j, j - 1);//如果没有发送交互则表示排序已经完成，但会多n次判断
                }
            }
        }
    }

    private static void selectSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) { //要放置正确元素的目标位置，最后一个不用放
            int min = i;

            for (int j = i + 1; j < len; j++) {
                if (arr[j] < arr[min]) { // 后面的大于前面
                    min = j;
                }
            }

            swap(arr, i, min);
        }
    }

    private static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {// 第一个不需要插入排序
            int temp = arr[i];
            int j = i - 1;
            while (j >= 0 && temp < arr[j]) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = temp;
        }
    }

    /*** quick ***/
    private static void quickSort(int[] arr, int left, int right) {
        if (left >= right) return;
        int pivotIndex = partition(arr, left, right);
        quickSort(arr, left, pivotIndex - 1);//排序 target 前面的
        quickSort(arr, pivotIndex + 1, right);//排序 target 后面的
    }

    private static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];//堆排序是原地排序，这个额外空间可以省去的，这里为了语义明确在此声明
        int target = left;
        for (int i = left; i < right; i++) {
            if (arr[i] < pivot) {
                swap(arr, target++, i);
            }
        }
        swap(arr, target, right);// target 已经处在正确的位置
        return target;
    }

    /*** merge：递归实现 从外向里 ***/

    private static void mergeSort(int[] arr, int left, int right) {
        if (left == right) return;//待排序列长度为1
        int middle = (left + right) / 2;
        mergeSort(arr, left, middle);
        mergeSort(arr, middle + 1, right);
        merge(arr, left, middle, right);
    }

    /*** merge：迭代实现 从里向外 ***/
    private static void mergeSort(int[] arr) {
        int len = arr.length;
        int left;//需要归并的左坐标
        int middle;//需要归并的中坐标（定义为左侧的结束端坐标），也就是步长的最后一个
        int right;//需要归并的右坐标
        for (int mergeLen = 1; mergeLen < len; mergeLen *= 2) {
            left = 0;
            while (left + mergeLen < len) { // 有后面的数组需要归并
                middle = left + mergeLen - 1;
                right = middle + mergeLen < len ? middle + mergeLen : len - 1;
                merge(arr, left, middle, right);
                left = right + 1;
            }
        }
    }

    private static void merge(int[] arr, int left, int leftEnd, int right) {
        int len = right - left + 1;
        int[] temp = new int[len];//辅助空间
        int tempIndex = 0;//辅助空间指针
        int i = left;//左侧指针
        int j = leftEnd + 1;//右侧指针
        while (i <= leftEnd && j <= right) {
            if (arr[i] <= arr[j]) {// 带等号保证归并排序的稳定性
                temp[tempIndex++] = arr[i++];
            } else {
                temp[tempIndex++] = arr[j++];
            }
        }
        while (i <= leftEnd) {
            temp[tempIndex++] = arr[i++];//左侧数组未
        }
        while (j <= right) {
            temp[tempIndex++] = arr[j++];
        }
        for (int k = 0; k < len; k++) {
            arr[left + k] = temp[k];//将辅助空间内容替换至真实数组的 left-right 空间
        }
    }

    /*** heap ***/
    private static void heapSort(int[] arr) {
        buildHeap(arr);//初始化大顶堆
        int maxHeapIndex = arr.length - 1;
        while (maxHeapIndex > 0) {// 堆（无序区）元素个数大于1，未完成排序
            swap(arr, 0, maxHeapIndex--);// 此处交换操作很有可能把后面元素的稳定性打乱，所以堆排序是不稳定的排序算法
            adjustHeap(arr, 0, maxHeapIndex);// 从新的堆顶元素开始向下进行堆调整，时间复杂度O(logn)
        }
    }

    private static void buildHeap(int[] arr) { // 建堆，时间复杂度O(n)
        int len = arr.length;
        for (int i = len / 2 - 1; i >= 0; i--) {//从最后一个非叶子节点开始，向上调堆，当i==0时，所有堆成为最大堆
            adjustHeap(arr, i, len - 1);
        }
    }

    private static void adjustHeap(int[] arr, int i, int maxIndex) {
        int leftChild = i * 2 + 1;
        int rightChild = i * 2 + 2;
        int max = i;
        if (leftChild <= maxIndex && (arr[leftChild] > arr[max])) {
            max = leftChild;
        }
        if (rightChild <= maxIndex && (arr[rightChild] > arr[max])) {
            max = rightChild;
        }
        if (max != i) {
            swap(arr, i, max);//把最大的换到当前堆顶，然后继续调剂被破坏的子堆
            adjustHeap(arr, max, maxIndex);// 保证被破坏的子堆继续维持大顶堆性质
        }
    }
}