八大排序算法思想汇总

1、冒泡排序

排序n-1次  每一次找到比较范围内的最大值

第 i 次排序时从 0 开始 至 倒数第( i-1 )结束，与相邻数值比较  找到最大值

优化：第 i 次排序全都没有发生交换时，下一次排序也不会再交换，可以直接break 提前结束

public static int[] bubbleSort(int[] arr_raw){
        //只要取n-1次  第i趟
        boolean flag=false;
        for(int i=0;i<arr_raw.length-1;i++){
            //后面已经有i个排好了，在最后，就不用再比较了  第j个元素与相邻元素比较
            for(int j=0;j<arr_raw.length-1-i;j++){
                int temp=0;
                if(arr_raw[j]>arr_raw[j+1]){
                    flag=true;
                    temp=arr_raw[j];
                    arr_raw[j]=arr_raw[j+1];
                    arr_raw[j+1]=temp;
                }
            }
            if(flag==false){
                break;
            }
            else {
                flag=false;
            }
        }
        return arr_raw;
    }

2、选择排序

排序n-1次  每一次找到区间内的最小值，并将其放置在 arr[i]的位置  注意放置时的交换顺序

每一次的最小值查询范围为：arr[i] - arr[length-1]

public static int[] selectSort(int[] arr_raw){
        for(int i=0;i<arr_raw.length;i++){
            int min=arr_raw[i];
            int minIndex=i;
            for(int j=i+1;j<arr_raw.length;j++){

                if(arr_raw[j]<min){
                    min=arr_raw[j];
                   minIndex=j;
                }
            }
            //因为min已经被记录了，所以先给被交换的那个下标赋值
            arr_raw[minIndex] = arr_raw[i];
            arr_raw[i]=min;

        }
        return arr_raw;
    }

3、插入排序

排序 n-1 次，从 arr[0] - arr[length-1] 依次插入，排第 i 个数时，前面第 i-1 个数是有序的

排第 i 个数时，依次与前面的有序数比较，必要时交换顺序

优化：排第 i 个数时，若不与其前面那个数交换，则不用再交换，可以break 退出本次插入（因为前面是有序的）

            注意是退出本次插入，冒泡是结束排序

优化2：采用移动法进行排序，需要注意的是，判别的insertIndex是当前下标的前一个，如果不再满足移动需求，跳出循环时，当前元素应该插入的位置是 insertIndex+1 的位置

//进行交换的插入排序
public static int[] insertSort(int[] arr){
        boolean flag=false;
        for(int i=1;i<arr.length;i++){
            for(int j= i;j>0;j--){
                //  前面是有序的，只要第一次不发生交换，就可以直接退出这次插入，跟冒泡还不一样
                if(arr[j]<arr[j-1]){
                    int temp;
                    flag=true;
                    temp = arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;

                }
                if(!flag){
                    break;
                }
                else {
                    flag=false;
                }
            }
        }
        return arr;
    }

//进行移动的插入排序
public static int[] insertSort2(int[] arr){
        for(int i=1;i<arr.length;i++){
            int insertValue = arr[i];
            int insertIndex=i-1;
            while(insertIndex>0 && arr[insertIndex]>insertValue){
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex+1]=insertValue;
        }
        return arr;
    }

4、希尔排序

核心思想是分组进行插入排序，使宏观上看起来有序，减少插入排序的负担。

分组依据是：gap=arr.length/2  gap=gap/2

i++ 配合上 int i=gap 能满足 insertIndex 不越界 且每一个数据都能插入排序（这里的 -gap 就很妙）

public static int[] shellSort(int[] arr){
        for(int gap=arr.length/2;gap>0;gap/=2){
            // i++ 是为了保证每一个数据都能在对应的组里  按顺序进行插入
            for(int i=gap;i<arr.length;i++){
                //记录要插入的数值
                int temp = arr[i];
                int insertIndex=i-gap;
                //后移直至查找到可以插入的位置
                if(arr[i]<arr[insertIndex]){
                    while(insertIndex>=0 &&arr[insertIndex]>temp){
                        arr[insertIndex + gap] = arr[insertIndex];
                        insertIndex-=gap;
                    }
                    arr[insertIndex+gap]=temp;
                }

            }
        }
        return arr;
    }