Java中常见的几种数组排序方法

冒泡排序

• 冒泡排序的原理（以元素进行从小到大排序为例）：

依次将相邻的两个元素进行两两比较，大的元素放到后面，第一次完毕后，最大的元素放在了最大索引处，针对所有的元素重复以上的步骤，除了最后一个元素，直到没有任何一对数据进行比较。

import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = {6, 5, 3, 1, 8, 7, 2, 4};
        for (int i = 0; i < arr.length - 1; i++) {
            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;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

选择排序

• 选择排序原理（元素从小到大排序为例）
  外部循环从起始元素开始到倒数第二个元素结束，先将外层循环的索引赋值给临时变量，然后接下来的内部循环中，如果发现有比这个最小位置处的元素更小的元素，则将那个更小的元素的索引赋给临时变量，最后，内部循环退出后；如果临时变量改变，则说明，有比当前外层循环位置更小的元素，需要将这两个元素交换

import java.util.Arrays;

public class ArrayDemo {
    //数组排序之选择排序
    public static void main(String[] args) {
        int[] arr = {2, 1, 6, 9, 5, 4};
        int minIndex = 0;   //定义一个最小元素的索引
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            minIndex = i;   //从0索引开始，将索引赋给minIndex
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;//找到最小值的索引
                }
            }
            //将最小元素放到本次循环的前端
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }    //然后寻找下次循环中最小元素放于下次循环的最前端
        System.out.println(Arrays.toString(arr));
    }
}

直接插入排序

• 选择排序原理（元素从小到大排序为例）
  每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。
  第一次比较前两个数，将小的数字放在前面，使之成为有序表（第0位独自作为有序数列，从第1位开始向后遍历）； 第二次将第三个数从后向前按照大小插入到有序表中；依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。

import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = {11, 45, 23, 2, 66, 54};
        for (int i = 1; i < arr.length; i++)//第0位独自作为有序数列，从第1位开始向后遍历
        {
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
                j--;     //往前递减是当前元素接着与前一个元素进行比较
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

快速排序

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

• 方法（挖坑填数法）
  1.基数处挖第一个坑（一般将数组中第一个数作为基数）；
  2.从后向前找比他小的数，找到后挖一个坑，然后把这个数填到前一个坑中；
  3.从前向后找比他大或者等于的数，找到后挖一个坑，然后把这个数填到前一个坑中；
  4.重复2，3步骤。

public class QuickSort {
    //方法中的三个参数：数组arr,要对arr[start]-arr[end]进行排序
    public static void sort(int[] arr, int start, int end) {
        if (start < end) {//递归的出口，不能相等，不然会死递归
            //构建方法获取分区索引
            int index = getIndex(arr, start, end);
            sort(arr, start, index - 1);//右半段进行排序
            sort(arr, index + 1, end);//左半段进行排序
        }
    }

    private static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定义一个基准数
        int x = arr[i];
        while (i < j) {//循环开始
            //先从右到左比较
            while (i < j && arr[j] > x) {
                j--;
            }
            //如果比基准数小了，就进行填坑
            if (i < j) {
                arr[i] = arr[j];//填到上一个坑位
                i++;
            }
            while (i < j && arr[i] <= x) {//从左往右比较
                i++;
            }
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }//当上面的循环结束后把基准数填到最后一个坑位，也就以基准数为界，分成了左右两部分
        arr[i] = x;//填回基准数
        return i;//返回基准数的索引
    }
}

调用此方法

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] arr = {33, 43, 22, 20, 34, 20, 66};
        QuickSort.sort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

二分法查找（在有序表中查找某一元素）

思想：每一次都查找中间那个元素，比较大或者小就减少一半的元素，然后在新的有序表中查找中间那个元素，直到找到所要找的元素。

import java.util.Arrays;

public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] arr = {11, 45, 23, 2, 66, 54};
        Arrays.sort(arr);
        int index = getNum(arr, 45);
        System.out.println("index: " + index);
    }

    private static int getNum(int[] arr, int num) {
        int minIndex = 0;
        int maxIndex = arr.length - 1;
        int midIndex = (maxIndex + minIndex) / 2;
        while (minIndex < maxIndex) {         //如果相等会死循环
            if (num == arr[midIndex]) {
                return midIndex;
            } else if (arr[midIndex] > num) {
                maxIndex = midIndex - 1;
            } else if (arr[midIndex] < num) {
                minIndex = midIndex + 1;
            }
            int midIndex = (maxIndex + minIndex) / 2；
        }
        return -1;
    }
}

注意：如果原数组是无序的，不能排序后再二分查找，因为排序后元素的索引变了。