排序算法 基础

冒泡排序：

步骤1: 比较相邻的元素。如果第一个比第二个大，就交换它们两个；

步骤2: 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

步骤3: 针对所有的元素重复以上的步骤，除了最后一个；

步骤4: 重复步骤1~3，直到排序完成。

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));

    }

快速排序：

假设一开始序列{xi}是：5，3，7，6，4，1，0，2，9，10，8。

此时，ref=5，i=1，j=11，从后往前找，第一个比5小的数是x8=2，因此序列为：2，3，7，6，4，1，0，5，9，10，8。

此时i=1，j=8，从前往后找，第一个比5大的数是x3=7，因此序列为：2，3，5，6，4，1，0，7，9，10，8。

此时，i=3，j=8，从第8位往前找，第一个比5小的数是x7=0，因此：2，3，0，6，4，1，5，7，9，10，8。

此时，i=3，j=7，从第3位往后找，第一个比5大的数是x4=6，因此：2，3，0，5，4，1，6，7，9，10，8。

此时，i=4，j=7，从第7位往前找，第一个比5小的数是x6=1，因此：2，3，0，1，4，5，6，7，9，10，8。

此时，i=4，j=6，从第4位往后找，直到第6位才有比5大的数，这时，i=j=6，ref成为一条分界线，它之前的数都比它小，之后的数都比它大，对于前后两部分数，可以采用同样的方法来排序。

步骤1：从数列中挑出一个元素，称为 “基准”（pivot ）；

步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

    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;

    }

选择排序：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

    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));

    }

插入排序：

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));

}