排序

    public static void main(String[] args) {
        int[] arr = {213, 123, 12, 4, 9, 12};
        quickSort(arr, 0, arr.length - 1);
        guibingSort(arr, 0, arr.length - 1);
        duiSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    //        快排
    private static void quickSort(int[] arr, int start, int end) {
        if (start >= end) {
            return;
        }
        int base = arr[start];
        int i = start;
        int j = end;
        while (i < j) {
            while (base <= arr[j] && i < j) {
                j--;
            }
            while (base >= arr[i] && i < j) {
                i++;
            }
            if (i < j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        arr[start] = arr[i];
        arr[i] = base;
        quickSort(arr, start, i - 1);
        quickSort(arr, i + 1, end);
    }

    //    归并
    private static void guibingSort(int[] arr, int start, int end) {
        if (start >= end) {
            return;
        }
        guibingSort(arr, start, (start + end) / 2);
        guibingSort(arr, (start + end) / 2 + 1, end);
        merge(start, end, arr);
    }

    private static void merge(int start, int end, int[] arr) {
        int mid = (start + end) / 2;
        int i = start;
        int j = mid + 1;
        int[] temp = new int[end - start + 1];
        int point = 0;
        while (i <= mid && j <= end) {
            if (arr[i] <= arr[j]) {
                temp[point++] = arr[i++];
            } else {
                temp[point++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[point++] = arr[i++];
        }
        while (j <= end) {
            temp[point++] = arr[j++];
        }
        point = 0;
        while (point < temp.length) {
            arr[start++] = temp[point++];
        }
    }


    //    堆排
    private static void duiSort(int[] arr) {
        for (int i = (arr.length - 1) / 2; i >= 0; i--) {
            adjust(arr, arr.length, i);
        }
        for (int i = arr.length - 1; i > 0; i--) {
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            adjust(arr, i, 0);
        }
    }

    private static void adjust(int[] arr, int length, int parent) {
        int leftChild = parent * 2 + 1;
        while (leftChild < length) {
            if (leftChild + 1 < length && arr[leftChild] < arr[leftChild + 1]) {
                leftChild++;
            }
            if (arr[parent] >= arr[leftChild]) {
                return;
            } else {
                int temp = arr[parent];
                arr[parent] = arr[leftChild];
                arr[leftChild] = temp;
                adjust(arr, length, leftChild);
            }
        }
    }
}