三种简单的排序方法

本章核心：主要从它们的 【有序区间】【无序区间】 的维度进行解释几种排序

整个排序数组这样看：[无序区间][有序区间]。那么刚开始就是整个数组都是无序区间，而有序区间在刚开始时没有元素的。我们每次把无序空间元素比较完后，放入有序区间，最后排序完成就是整个都是有序空间，无序区间为空。

---

冒泡排序

冒泡排序的主要思想：（关注的是无序空间，目标是要把无序空间经历完）

外部循环控制比较轮数，内部循环控制每个元素比较次数

外部当我们有size个元素的时候，我们需要进行size-1次循环，内部循环我们会将元素两两比较，把每轮比较好的元素（每轮比较出来的最大或最小元素），放到后边。

后边就是我们的有序区间，前边是我们的无序区间，我们一边比较，一边把比较好的元素方法加入到我们的有序区间，有序区间元素会越来越多，无序区间元素会越来越少，直到我们把无序区间的元素全部比较完毕。

排序整个数组

 
//排序都会用到的交换方法
public static void swap(long[] array,int i,int j){
        long t=array[i];
        array[i]=array[j];
        array[j]=t;
    }

public static void bubbleSort(long[] array,int size){
       //冒泡的次数
        for(int i=0;i<size-1;i++){
            //无序区间：[0,size-i)
            //有序区间：[size-i,size)
           
            for(int j = 0;j<size-i-1;j++){
                if (array[j] > array[j+1]) {
                    swap(array,j,j+1);
                    
                }
            }
            
        }
    }

排序给定范围元素

对array的[fromIndex,toIndex)进行冒泡排序（fromIndex和toIndex一定合法）

    public static void bubbleSortRange(long[] array,int fromIndex,int toIndex){
        int n=toIndex - fromIndex;
        for(int i=0;i<n;i++){
            //进行n次循环
            //我们要排的是无序区间[fromIndex,toIndex-i)
            //j指的是无序空间的起始
            for(int j=fromIndex;j<toIndex-i-1;j++){
                if(array[j]>array[j+1]){
                    swap(array,j,j+1);
                }
            }
        }
    }

选择排序

选择排序思想：遍历数组，每次找到其中最大（最小）元素下标，交换到数组的最后边（最前边）。

每从找最大元素放到在最后边

遍历无序区间，每次找到无序区间中最大的元素的下标，然后把最大元素交换到最后边的有序区间。

区间划分：[无序区间][有序区间]

 public static void selectSort(long[] array,int size){
        //一共需要size-1次选择过程
        for (int i=0;i<size-1;i++){
            //无序区间：[0,size-i)
            //有序区间：[size-i,size)
            int maxIdx = 0;//假设最大元素下标为第0个元素
            for (int j = 1; j < size-i; j++) {
                //直接从第一个元素开始比较，第0个元素已经被取出来了
                if(array[j]>array[maxIdx]){
                    maxIdx = j;//把它的下标赋值给最大元素下标，找到最大的元素的下标
                }
            }
            //每次找到最大的元素下标，把最大的元素换到最后边
            swap(array,maxIdx,size-i-1);
        }
    }

每从找最小元素放到在最前边

遍历无序区间，每次找到无序区间中最小的元素的下标，然后把最小元素交换到最前边的有序区间。

区间划分：[有序区间][无序区间]

 public static void selectSrt1(long[] array,int size){
        for (int i = 0; i < size-1; i++) {
            //无序区间：[i,size)
            //有序区间：[0,i)
            int minIdx = i;//选择无序区间的第一个元素为最小的元素下标
            for (int j = i+1; j < size; j++) {
                if(array[j]<array[minIdx]){
                    minIdx=j;
                }
            }
            swap(array,minIdx,i);

        }
    }

每次找两个区间，最小区间放前边，最大区间放后边

前两种的结合

区间划分：[有序区间小元素] [无序区间] [有序区间大元素]

public static void selectSort2(long[] array,int size){
        int leftIdx=0;
        int rightIdx=size;
        //有序小区间：[0,leftIdx)
        //无序区间：[leftIdx,rightIdx)
        //有序大区间：[rightIdx,size)
        //无序区间个数：rightIdx-leftIdx

        //当无序区间个数大于等于1的时候，循环
        while(rightIdx-leftIdx>=1){
            int minIdx=leftIdx;
            int maxIdx=rightIdx;
            //遍历整个无序区间
            for(int i=leftIdx;i<rightIdx;i++){
                if(array[i]<array[minIdx]){
                    minIdx=i;
                }
                if(array[i]>array[maxIdx]){
                    maxIdx=i;
                }
            }
            //交换最小元素到有序区间最小元素leftIdx;
            //交换最大元素到有序区间最大元素rightIdx-1
            swap(array,minIdx,leftIdx);
            swap(array,maxIdx,rightIdx-1);

            leftIdx++;
            rightIdx--;
        }
    }

插入排序

插入排序和前边两种关注的不一样，插入排序关注的是有序区间。

从无序区间第一个元素开始，和有序区间元素逆序进行比较，当它小于有序区间比较的元素的时候，继续向前比较，只有当它大于等于有序区间比较的元素的时候，将他插入比较元素的后一个位置。

区间划分：[有序区间][无序区间]  （注意：有序区间我们最开始划分的时候，就把第0个元素放进去，因为不管第0个元素是什么，当有序区间只有一个元素的时候，它都是有序的）

排序整个数组元素

public static void insertSort1(long[] array,int size){
       //外层循环是要插入几次的次数
        //i的含义是要插入的元素,要插入的元素从第一个元素开始
        for(int i=1;i<size;i++){
            //有序区间：[0,i)
            //无序区间：[i,size)

            //内层循环是插入的元素和有序区间元素逆序做比较，
            //大于等于的时候则停止，插入比较元素的后一个位置
            //而如果一直小于比较的元素，那么就一直超前比较
            long key=array[i];
            int j;
            for(j=i-1;j>=0 && key<array[j];j--){
                array[j+1]=array[j];
            }
            //循环结束则说明找到了合适的位置，把元素插入到j+1的位置
            array[j+1]=key;
        }
    }

排序数组中部分元素

public static void insertSort2(long[] array,int fromIdx,int toIdx){
        int n=toIdx-fromIdx;
        for(int i=1;i<n;i++){
            //有序区间：[fromIdx,fromIdx+i)
            //无序区间：[fromIx+i,toIdx)
            //带插入元素的下标：[fromIdx+i]
            long key=array[i];
            int j;
            for (j = fromIdx+i-1; j >=fromIdx && key<array[j] ; j--) {
                array[j+1]=array[j];
            }
            array[j+1]=key;
        }
    }

以上便是三种简单的排序的实现，欢迎指正~