java常见算法 冒泡排序，选择排序，插入排序，快速排序---后面还要更新一下复杂度之类的情况

import java.util.Arrays;

public class Sort2 {
    public static void main(String args[]) {
        int[] array = new int[] { 3, 5, 1, 2, 7, 6, 4, 8, 7 };
//        selectSort(array);
        quickSort(array, 0, array.length - 1);
//        bubbleSort(array);
//        insertSort(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 冒泡排序，升序 两两比较，较大的数往后面冒
     * 
     * @param array
     */
    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                // 大数往后冒
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }

    /**
     * 选择排序，升序 寻找最小值然后交换
     * 
     * @param array
     */
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int min = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[min] > array[j]) {
                    min = j;
                }
            }
            if (min != i) {
                int temp = array[i];
                array[i] = array[min];
                array[min] = temp;
            }
        }
    }

    /**
     * 插入排序 将数组分为[0,index-1]的有序数列和[index,array.length]无序数列两部分 
     * 提取array[index]的值记为temp，准备插入左侧有序数列
     * 之后从有序数列右侧开始遍历，全体向右偏移一位，直至找到合适的插入点
     * 参考https://blog.csdn.net/qq_42857603/article/details/81605124
     * 
     * @param array
     */
    public static void insertSort(int[] array) {
        for (int index = 1; index < array.length; index++) {
            //temp为要插入到左侧的数
            int temp = array[index];
            int leftindex = index - 1;
            // 大数往后移动
            while (leftindex >= 0 && array[leftindex] > temp) {
                array[leftindex + 1] = array[leftindex];
                leftindex--;
            }
            array[leftindex + 1] = temp;
        }
    }
    /**
     * 快速排序
     * 参考https://blog.csdn.net/shujuelin/article/details/82423852
     * 
     * @param array
     * @param low
     * @param high
     */
    public static void quickSort(int[] array, int low, int high) {
        if (low > high) {
            return;
        }
        int i = low;
        int j = high;
        int base = array[low];
        while (i < j) {
            // 先看右边，找到第一个小于基准点的数
            while (i < j && array[j] >= base) {
                j--;
            }
            // 再看左边，找一个大于基准点的数
            while (i < j && array[i] <= base) {
                i++;
            }
            if (i < j) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;

            }
        }
        // 最后将基准位与i和j相等位置的数字交换
        array[low] = array[i];
        array[i] = base;
        //递归调用排序左侧
        quickSort(array, low, i - 1);
        //递归调用排序右侧
        quickSort(array, i + 1, high);
    }

}

标签：index,java,temp,int,冒泡排序,length,leftindex,array,排序
来源： https://www.cnblogs.com/lz-0011/p/10890644.html