排序算法

1-冒泡排序

   /*
    * 冒泡排序
    * 冒泡排序只会操作相邻的两个数据，每次冒泡操作对相邻的两个元素进行比较，看是否满足大小关系要求
    * 如果不满足就让他们交换，一次冒泡会让至少一个元素移动到他应该在的位置
    * */
    public static void bubbleSort(Integer[] arr) {
        //数组长度<=1不用排序
        if (arr.length <= 1) {
            return;
        } else {
            //带引排序前的数组
            System.out.println("排序前的数组为：" + Arrays.toString(arr));
            for (int i = 0; i < arr.length - 1; i++) {
                //提前退出冒泡循环的标志，即一次比较中没有交换任何元素，这个数组已经是有序的了
                boolean flag = false;
                for (int j = 0; j < arr.length - i - 1; j++) {
                    if (arr[j] > arr[j + 1]) {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                        flag = true;
                    }
                }
                if (!flag)
                    //没有数据交换，数组已经有序，退出排序
                    break;
            }
        }
    }

2-选择排序

	/*
     * 选择排序
     * 先遍历数组，然后找到一个最大或最小的元素，把这个元素移动到第一个位置
     * 接着再从剩余的数组中继续找第二大或第二小的元素，放到第二个位置
     * 重复操作，直到完成排序
     * */
    public static void selectSort(Integer[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            //记录最小值的索引，默认值为i
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[minIndex] > arr[j]) {
                    minIndex = j;
                }
            }
            //交换索引i和minIndex两处的元素
            if (i != minIndex) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

3-插入排序

一组无序序列{A1,A2,……An}，先取出A1，然后从A2与A1比较，比较完之后序列状况是{A1,A2}{A3……An}，这时候其中{A1,A2}就变成有序，然后取出A3 ，放到{A1,A2}有序序列合适位置，从而形成{A1,A2,A3}{A4……An}，重复这个过程，直到取出An放入{A1,A2……An-1}有序序列中。

	/*
     * 插入排序
     * 一组无序序列{A1,A2,……An}
     * 先取出A1，然后从A2与A1比较，比较完之后序列状况是{A1,A2}{A3……An}，
     * 这时候其中{A1,A2}就变成有序
     * 然后取出A3 ，放到{A1,A2}有序序列合适位置，从而形成{A1,A2,A3}{A4……An}
     * 重复这个过程，直到取出An放入{A1,A2……An-1}有序序列中
     * */
    public static void insertSort(Integer[] arr) {
        for (int i = 1; i < arr.length; i++) {
            //保存每次需要插入的那个数
            int temp = arr[i];
            int j;
            for (j = i; j > 0 && arr[j - 1] > temp; j--) {
                //把大于需要插入的数往后移动，最后不大于temp的数就会空出来
                arr[j] = arr[j - 1];
            }
            //将需要插入的数放入这个位置
            arr[j] = temp;
        }
    }

4-快速排序

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

	/*
     * 快速排序
     * @param arr           待排序列
     * @param leftIndex     待排序列起始位置
     * @param rightIndex    待排序列结束位置
     * */
    public static void quickSort(Integer[] arr, int leftIndex, int rightIndex) {
        if (leftIndex >= rightIndex) {
            return;
        } else {
            int left = leftIndex;
            int right = rightIndex;
            //待排序的第一个元素作为基准值
            int key = arr[left];
            //从左右两边交替扫描，直到left=right
            while (left < right) {
                while (left < right && arr[right] >= key) {
                    //从右往左扫描，找到第一个比基准值小的元素
                    right--;
                }
                //找到这种元素将arr[right]放入arr[left]中
                arr[left] = arr[right];
                while (left < right && arr[left] <= key) {
                    //从左往右扫描，找到第一个比基准值大的元素
                    left++;
                }
                //找到这种元素将arr[left]放入arr[right]中
                arr[right] = arr[left];
            }
            //基准值归位
            arr[left] = key;
            //对基准值左边的元素进行递归排序
            quickSort(arr, leftIndex, left - 1);
            //对基准值右边的元素进行递归排序
            quickSort(arr, right + 1, rightIndex);
        }
    }