java排序算法

class Solution {
    void bubbleSort(int[] arr) {
        boolean remain = false;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] < arr[j + 1]) {
                    remain = true;
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
            if (!remain) {
                break;
            }
            remain = false;
        }
        System.out.println(Arrays.toString(Arrays.stream(arr).toArray()));
    }

    void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int tmp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = tmp;
        }
        System.out.println(Arrays.toString(Arrays.stream(arr).toArray()));
    }

    void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j--;
            }
            arr[j] = tmp;
        }
        System.out.println(Arrays.toString(Arrays.stream(arr).toArray()));
    }

    void shellSort(int[] arr) {
        for (int step = arr.length; step >= 1; step = step / 2) {
            int temp;
            for (int i = 0; i < arr.length; i++) {
                temp = arr[i];
                int j = i - step;
                while (j >= 0 && arr[j] > temp) {
                    arr[j + step] = arr[j];
                    j = j - step;
                }
                arr[j + step] = temp;
            }
        }
        System.out.println(Arrays.toString(Arrays.stream(arr).toArray()));
    }
    void mergeSort(int[] arr) {
        System.out.println(Arrays.toString(Arrays.stream(mergeSort1(arr)).toArray()));
    }

    int [] mergeSort1(int[] arr) {
        if (arr.length < 2) {
            return arr;
        }
        int mid = arr.length / 2;
        int []left = Arrays.copyOfRange(arr, 0, mid);
        int []right = Arrays.copyOfRange(arr, mid, arr.length);
        return merge(mergeSort1(left), mergeSort1(right));
    }

    private int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int index = 0;
        int leftIndex = 0;
        int rightIndex = 0;
        while (leftIndex < left.length && rightIndex < right.length) {
            if (left[leftIndex] > right[rightIndex]) {
                result[index] = right[rightIndex];
                rightIndex++;
            } else {
                result[index] = left[leftIndex];
                leftIndex++;
            }
            index++;
        }
        while (leftIndex < left.length) {
            result[index] = left[leftIndex];
            index++;
            leftIndex++;
        }


        while (rightIndex < right.length) {
            result[index] = right[rightIndex];
            index++;
            rightIndex++;
        }
        return result;
    }

    void quickSort(int []arr) {
        quickSort1(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(Arrays.stream(arr).toArray()));
    }

    private void quickSort1(int[] arr, int left, int right) {
        int i = left;
        int j = right;
        int flag = arr[left];
        while (i < j) {
            while (i < j && arr[j] > flag) {
                j--;
            }
            while (i < j && arr[i] < flag) {
                i++;
            }
            if (arr[i] == arr[j]) {
                i++;
            } else {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        if (i - 1 > left) {
            quickSort1(arr, left, i - 1);
        }
        if (j + 1 < right) {
            quickSort1(arr, j + 1, right);
        }
    }

    void heapSort(int []arr) {
        buildMaxHeap(arr, arr.length);
        int len = arr.length;
        for (int i = len- 1; i > 0 ; i--) {
            swap(arr, 0, i);
            len--;
            heapify(arr, 0, len);
        }
        System.out.println(Arrays.toString(Arrays.stream(arr).toArray()));
    }

    private void buildMaxHeap(int[] arr, int length) {
        for (int i = (int) Math.floor(length / 2); i >= 0; i--) {
            heapify(arr, i, length);
        }
    }

    private void heapify(int[] arr, int i, int length) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;
        if (left < length && arr[left] > arr[largest]) {
            largest = left;
        }
        if (right < length && arr[right] > arr[largest]) {
            largest = right;
        }
        if (largest != i) {
            swap(arr, i, largest);
            // xiacheng
            heapify(arr, largest, length);
        }
    }

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