7大排序算法

冒泡排序

public static int[] bobSort(int[] array) {
        int len = array.length;
        if (len < 2) {
            return array;
        }
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i;j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                }
            }
        }
        return array;
    }

选择排序

public static int[] selectSort( int[] array) {
        int len = array.length;
        if (len < 2) {
            return array;
        }
        for (int i = 0; i < len - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < len; j++ ) {
                if (array[minIndex] > array[j]) {
                    minIndex = j;
                }
            }
            if (i != minIndex) {
                swap(array, i, minIndex);
            }
        }
        return array;
    }

插入排序

public static int[] insertSort(int[] array) {
        int len = array.length;
        if (len < 2) {
            return array;
        }

        for (int i = 1; i < len; i++) {
            int temp = array[i];
            int leftIndex = i - 1;
            while (leftIndex >= 0 && array[leftIndex] > temp) {
                array[leftIndex + 1] = array[leftIndex];
                leftIndex--;
            }
            array[leftIndex + 1] = temp;
        }
        return array;
    }

 希尔排序

public static int[] shellSort(int[] array) {
        int len = array.length;
        int temp, gap = len / 2;
        while (gap > 0) {
            for (int i = gap; i < len; i++) {
                temp = array[i];
                int leftIndex = i - gap;
                while (leftIndex >= 0 && array[leftIndex] > temp) {
                    array[leftIndex + gap] = array[leftIndex];
                    leftIndex -= gap;
                }
                array[leftIndex + gap] = temp;
            }
            gap /= 2;
        }
        return array;
    }

快速排序

public static void QuickSort(int[] array, int left, int right) {
        if (left >= right) {
            return;
        }

        int index = PartSort(array, left, right);
        QuickSort(array, left , index - 1);
        QuickSort(array, index + 1, right);
    }

    private static int PartSort(int[] array, int left, int right) {
        int key = array[left];
        while (left < right) {
            while (left < right && array[right] <= key) {
                right--;
            }
            array[left] = array[right];
            while (left < right && array[left] >=key) {
                left++;
            }
            array[right] = array[left];
        }
        array[right] = key;
        return right;
    }

归并排序

 /**
     * 归并排序---将两段排好序的数组结合成一个排序数组
     * @param left
     * @param right
     * @return
     */
    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        //j代表左边数组的索引，i代表右边数组的索引
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (j >= left.length) {
                result[index] = right[i++];
            } else if (i >= right.length) {
                result[index] = left[j++];
            } else if (left[j] > right[i]) {
                result[index] = right[i++];
            } else {
                result[index] = left[j++];
            }
        }
        return result;
    }

    /**
     * 归并排序
     * @param array
     * @return
     */
    public static int[] mergeSort(int[] array) {
        if (array.length < 2) {
            return array;
        }
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        return merge(mergeSort(left),mergeSort(right));
    }

堆排序

static int len;
    public static int[] HeapSort(int[] array) {
        len = array.length;
        if (len < 2) {
            return array;
        }
        //1.构建一个最大堆
        buildMaxHeap(array);

        //2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆
        while (len > 0) {
            swap(array, 0 , len -1);
            adjustHeap(array,0);
            len--;
    }
        return array;
    }
    /**
     * 建立最大堆
     * @param array
     */
    public static void buildMaxHeap(int[] array) {
        //从最后一个非叶子开始向上构造最大堆
        for (int i = ( len - 1) / 2; i >= 0; i--) {
            adjustHeap(array,i);
        }
    }
    /**
     * 调整使之成为最大堆
     * @param array
     * @param i
     */
    public static void adjustHeap(int[] array, int i) {
        int maxIndex = i;
        //如果有左子树，而且左子树大于父节点，将最大指针指向左子树
        if (2 * i < len && array[maxIndex] < array[2 * i]) {
            maxIndex = 2 * i;
        }
        //如果有右子树，而且右子树大于父节点，将最大指针指向右子树
        if (2 * i + 1 < len && array[maxIndex] < array[2 * i + 1]) {
            maxIndex = 2 * i + 1;
        }

        //如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置
        if (maxIndex != i) {
            swap(array, i, maxIndex);
            adjustHeap(array,maxIndex);
        }
    }