详解七大基本排序：选择排序、冒泡排序、插入排序、希尔排序、归并排序、快速排序、堆排序

---

一、排序

1.排序种类

二、

1.选择排序O(N^2)

1.1选择排序O(N^2)

每次从无序区间选择一个最大或最小值，存放在无序区间的最前或最后的位置（此位置的元素已经有序），直到所有的数据都排序完成为止

//选择排序
    public static  void selectionSort(int[] arr){
   
        for (int i = 0; i < arr.length-1; i++) {
   
            int min = i;
            for (int j = i+1; j < arr.length ; j++) {
   
                if (arr[j]<arr[min]){
   
                    min = j;
                }
            }
            swap(arr,min,i);//只交换一次
        }
    }

    private static void swap(int[] arr, int i, int j) {
   
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

1.2双向选择排序

重点在于当max指向low时，需要交换max=min
if(max==low){max=min}；

//双向选择排序
    public static void selectionSortOP(int[] arr){
   
        int low = 0 ;
        int high = arr.length-1;
        //low等于high，无序区间只剩一个元素，整个数组已经有序
        while(low<=high){
   
            int max = low;
            int min = low;
            //low+1减少一次，第一个元素和自己比较
            for (int i = low+1; i <= high; i++) {
   
                if (arr[i]<arr[min]){
   
                    min = i;
                }
                if (arr[i]>arr[max]){
   
                    max = i;
                }
            }
            //min索引是当前最小值索引
            swap(arr,min,low);
            //此时min指向最小值,max指向最大值，但是恰巧low也指向max
            //因为先交换了min元素去low，所以此时min指向max元素，而max还指向原来的位置，所以交换max去min(最大元素位置)
            if (max == low) {
   
                max = min;
            }
            swap(arr,max,high);
            low++;
            high--;
        }
    }

2.冒泡排序O（N^2）

 public static void bubbleSort(int[] arr){
   
        for (int i = 0; i < arr.length; i++) {
   //轮数
            boolean isSwaped = false;
            for (int j = 0; j < arr.length-1-i; j++) {
   //交换次数
                if (arr[j]>arr[j+1]){
   
                    swap(arr,j,j+1);//每次都交换
                    isSwaped = true;
                }
            }
            if (!isSwaped) {
   
                break;
            }
        }
    }

和选择排序相比较，同为0（n^2）,但是选择排序比冒泡排序快，因为交换次数不同

3.插入排序O(N^2)

3.1直接插入排序

将集合分为两个区间：i就是当前遍历元素，已经排序的区间[0…i),待排序的区间[i…n]
每次从待排序区间中将第一个元素“插入”到已经排序区间的合适位置，直到这个数组有序。

    //直接插入排序
    //每次从待排序区间将第一个元素插入到已排序区间的合适位置
    public static void insertionSort(int[] arr) {
   
         //已排序区间[0,i),待排序区间[i...n]
        for (int i = 1; i < arr.length ; i++) {
   
            //待排序区间第一个元素arr[i]
            //从待排序区间的第一个元素向前，找到合适的位置
            for (int j = i; j >0 ; j--) {
   
                //arr[j-1]已排序区间的最后一个元素
                if (arr[j] >= arr[j-1]) {
   
                    //相等也不叫唤，保证稳定性
                    //此时说明arr[j],已排序区间的最大值，arr[j]已经有序
                    break;
                }else{
   
                    swap(arr,j,j-1);
                }
            }
        }
    }

简化中间的for (int j = i; j >0 ; j–){}

  for (int j=i;j>0 && arr[j]<arr[j-