数组排序方法

冒泡排序

**排序思想：**相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。

选择排序

**排序思想：**第一个数依次与后面的数比较，第一次比较完之后最小的数在最前面 。如果前面的数大于后面的数，就进行位置的交换。

  public class Dome2 {
                            public static void main(String[] args) {
                                 //数组
                                 int[] arr = {5,3,7,2,6,7,6,5,4,1,9,8};
                                //第一次循环，是确定一个数依次和后面数的比较的数。
                                for (int i = 0; i < arr.length -1 ; i++) {
                                   //这个是和第一个数的比较的数
                                    for (int j = i+1; j < arr.length; j++) {
                                      //定义一个临时的变量，用来交换变量
                                       int temp ;  
                                       if(arr[i]>arr[j]){
                                            temp =  arr[i];
                                            arr[i] = arr[j];
                                            arr[j] = temp;
                                       }
                                   }
                                }
                        //打印最后的排序结果
                        System.out.println(Arrays.toString(arr));
                         }
                }

快速排序

**排序思想：**冒泡排序的一种优化，挖坑填数。

public class QuickSortUtils {
    /**
     * @param arr   要排序的数组
     * @param start 要排序的起始位
     * @param end   要排序的结束位置 数组长度-1
     */
    public static void quickSort(int[] arr, int start, int end) {
        if (start < end) {
            //找出中间索引
            int index = getIndex(arr, start, end);
            //分成左右两半,对左右凉拌进行递归调用
            quickSort(arr, start, index - 1);//递归排序左半部分
            //递归排序右半部分
            quickSort(arr, index + 1, end);
        }
    }

    /**
     * @param arr   要排序的数组
     * @param start 开始位置
     * @param end   结束位置
     * @return 返回的是分区的中间索引
     */
    //挖坑填数
    private static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定义基准数
        int x = arr[i];
        while (i < j) {
            //1.先从后往前找
            while (i < j && arr[j] > x) {//
                j--;
            }
            //挖坑填数
            if (i < j) {
                arr[i] = arr[j];//填坑
                i++;//顺遍让i 递增一下
            }
            //2.从前往后找
            while (i < j && arr[i] <= x) {
                i++;
            }
            //挖坑填数
            if (i < j) {
                arr[j] = arr[i];//填坑
                j--;//顺遍让j 递减一下
            }
        }
        arr[i] = x;//把基准数填到最后一个坑里
        return i;
    }
}

直接插入排序

**排序思想：**每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。