四种常见的排序算法（冒泡，选择，插入，快速排序）

下面列举常用的四种算法

1.冒泡排序：

    /**
     * 冒泡排序：
     * 原理：比较两个相邻的元素，将值大的元素放在后面
     * <p>
     * 第一层的循环是需要遍历的次数
     * 第二层的循环是 每次都是重 新两两比较（除去之前得到的最大值），得到值大的元素放在后面
     */
   public void initMaoPao(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        System.out.print(Arrays.toString(arr));
    }

2.选择排序：

 /**
     * 选择排序：
     * 原理：每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕
     * <p>
     * 第一层：从第一个元素开始比较后面的元素。
     * 第二层：得到的值小的元素和该位置交换，下次循环arr[i] 就是那个较小的值，对以后的元素比较，一次类推
     */
    public void chooseSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.print(Arrays.toString(arr));
    }

3.插入排序：

    /**
     * 简单插入排序：
     * 原理：每一个元素都要和之前的已经排好的元素做比较
     */
    public void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < i; j++) {
                if (arr[i] < arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        System.out.print(Arrays.toString(arr));
    }

4.快速排序：

 /**
     * 面试中较为常见的算法之一就是快速排序，
     * 快速排序在实际排序应用中也是最好的选择，因为它的平均性能非常好，它的期望复杂度为nlgn，
     * 另外，它还是一种稳定的排序方法。快速排序利用分治思想，将待排序数组分成左右两个部分，然后对其分别递归调用快速排序算法。
     * <p>
     * 采用分治法的思想：
     * 首先设置一个轴值pivot，然后以这个轴值为划分基准将待排序序列分成比pivot大和比pivot小的两部分，
     * 接下来对划分完的子序列进行快排直到子序列为一个元素为止
     */

    public void quickSort(int[] arr, int low, int high) {

        //查找轴值pivot
        if (low < high) {
            int MiddlePivot = getMiddlePivot(arr, low, high);
            //运用分治法的思想对数组进行递归。
            getMiddlePivot(arr, low, MiddlePivot - 1);
            getMiddlePivot(arr, MiddlePivot + 1, high);
        }

        System.out.print(Arrays.toString(arr));
    }

    public int getMiddlePivot(int[] arr, int low, int high) {

        //默认一最左边的为基数，一部分从左边开始++，一部分从右边--；
        int baseValue = arr[low];
        int baseIndex = low;

        while (low < high) {
            while (low < high && arr[high] > baseValue) {
                high--;
            }

            //1.找到小于基数的元素后，与基数交换位置
            arr[baseIndex] = arr[high];
            baseIndex = high;//确保以后取到的值还是基数值；
            arr[high] = baseValue;

            while (low < high && arr[low] < baseValue) {
                low--;
            }

            //找到比基数大的元素 与 上面更换位置后的元素（1步之后） 交换位置
            arr[baseIndex] = arr[low];
            baseIndex = low;
            arr[low] = baseValue;
        }

        return baseIndex;
    }

参考：1.百度百科之快速排序
2.算法排序----快速排序法