Java实现排序

排序

冒泡排序

    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }

选择排序

    public static void selectionSort(int[] arr){
        int min_index;
        for (int i = 0; i < arr.length; i++) {
            min_index = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[min_index] > arr[j]){
                    min_index = j;
                }
            }
            int tmp = arr[i];
            arr[i] = arr[min_index];
            arr[min_index] = tmp;
        }
    }

插入排序

    public static void insertionSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]){
                    int tmp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = tmp;
                }else {
                    break;
                }
            }
        }
    }

希尔排序

    public static void shellSort(int[] arr){
        for (int gap = arr.length/2; gap > 0; gap /= 2) {//增量

            for (int i = gap; i < arr.length; i++) {
                for (int j = i; j - gap >= 0; j -= gap) {
                    if (arr[j] < arr[j - gap]){
                        int tmp = arr[j];
                        arr[j] = arr[j - gap];
                        arr[j - gap] = tmp;
                    }else {
                        break;
                    }
                }
            }
        }
    }

归并排序

    public static void mergeSort(int[] arr){
        int[] temp = new int[arr.length];
        divide(arr, 0, arr.length - 1, temp);
    }

    private static void divide(int[] arr, int start, int end, int[] temp){//分
        if (start < end){
            int mid = (start + end)/2;
            divide(arr, start, mid, temp);
            divide(arr,mid + 1, end, temp);
            merge(arr, start, mid, end, temp);
        }
    }

    private static void merge(int[] arr, int start, int mid, int end, int[] temp){//治
        int index_left = start;
        int index_right = mid + 1;
        int index = 0;

        //比较并放入temp数组中
        while ((index_left <= mid) && (index_right <= end)){
            if (arr[index_left] < arr[index_right]){
                temp[index++] = arr[index_left++];
            }else {
                temp[index++] = arr[index_right++];
            }
        }

        //如果左半部分有省的，则将其全部存入temp数组中
        while (index_left <= mid){
            temp[index++] = arr[index_left++];
        }

        //如果右半部分有省的，则将其全部存入temp数组中
        while (index_right <= end){
            temp[index++] = arr[index_right++];
        }

        for (int i = end; i >= start; i--) {
            arr[i] = temp[--index];
        }
    }

快速排序

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

    private static void quickSort(int[] arr, int start, int end){
        if (start < end){
            int pivot = arr[end];
            int left = start;
            int right = end;
            while (left != right){
                while (arr[left] < pivot){
                    left++;
                }
                if (left != right){
                    arr[right--] = arr[left];
                }
                while (arr[right] > pivot && left != right){
                    right--;
                }
                if (left != right) {
                    arr[left++] = arr[right];
                }
            }
            arr[left] = pivot;
            quickSort(arr, start, left - 1);
            quickSort(arr, left + 1, end);
        }
    }