算法-排序

/**
     * 插入排序
     * 两层循环，外层循环表示无序数组，内层循环代表有序数组
     * 默认无序第一个数据为有序数组，首次外层循环从1开始
     * 例子： 6,5,4 ，第一次   5，6，4  第二次  5，4，6  ->4,5,6
     * 时间复杂度：最坏的情况下为O(N^2),此时整个数列接近逆序。最好情况下为O(N),此时整个数列接近有序；
     * 空间复杂度：O(1)；
     * 不稳定
     * @param array
     */
    public static void  SortInsert(int[] array){
        if(array==null||array.length==1){
            return;
        }
        for(int i=1;i<array.length;i++){
             int temp=array[i];
             for(int j=i-1;j>=0;j--){
                 if(temp<array[j]){
                    array[j+1]=array[j];//置换位置
                    array[j]=temp;//
                 }else {
                     break;
                 }
             }
        }
    }

/**
     * 选择排序-确定无序数组的最小的数值放到数组前面位置
     * 先确定最小的数字放在数组最左侧，循环该过程
     * 例子： 6,5,4 一次排序：5,6,4 ->4,6,5 二次排序：4，5，6
     * @param target
     */
    private static void selectSort(int[] target) {
        if(target==null||target.length==1){
            return;
        }
         /* for(int i=0;i<target.length;i++){
              for(int j=i+1;i<target.length;j++){
                  if(target[i]>target[j]){
                      int temp=target[i];
                      target[i]=target[j];
                      target[j]=temp;
                  }
              }
          }*/
          //优化思路；每次比对都要交换两个下标数据，那么记录最小数据的下标，循环结束再置换
          for(int i=0;i<target.length;i++){
              int temp=i;
              for(int j=i+1;j<target.length;j++){
                  if(target[temp]>target[j]){
                      temp=j;
                  }
              }
              int tem=target[i];
              target[i]=target[temp];
              target[temp]=tem;
          }
    }

 /**
     * 冒泡排序：每次把无序数组的最大值放到数组后面
     * 例子： 6,5,4  一次：5，6，4，->5,4,6 二次； 4,5,6
     * 时间复杂度：O(N^2)；
     *
     * 空间复杂度：O(1)；
     *
     * 稳定
     * @param array
     */
    public static void bubbleSort01(int[] array) {
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        //优化 有序数组，标记位一次遍历即可
       /* for(int i=0;i<array.length;i++){
            boolean b=false;
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    b=true;
                }
            }
            if(b==false){
                break;
            }
        }*/
    }

 /**
     * 快排
     * 时间复杂度：递归的时间复杂度是O(logn),交换是o（1），但游标移动的时间复杂度是o(n)，所以总体来说时间复杂度是O（nlogn）
     * 参考：[https://blog.csdn.net/m566666/article/details/121711988](https://blog.csdn.net/m566666/article/details/121711988)
     * @param array
     * @param l
     * @param r
     */
    public static  void  quickSort(int array[],int l,int r){
        if(l>=r){
            return;
        }
        int temp=array[l];  //基准值，一般默认第一个数据
        int left=l,right=r;
        while (left<right){

            while (left<right&&array[right]>=temp){  //先右侧寻找小于基准的值
                  right--;
            }
            if(left<right) {   //覆盖左侧的值
                array[left] = array[right];
            }

            while (left<right&&array[left]<=temp) {  //左侧指针寻找大于基准的值
                left++;
            }
            if(left<right) {  //覆盖右侧的值
                array[right] = array[left];
            }
        }
        array[left]=temp;  //将基准值，放在临界点

        if(l<left){   //递归基准值左侧
            quickSort(array,l,left-1);
        }
        if(left<r){  //递归基准值右
            quickSort(array,left+1,r);
        }
    }

 /**
     * 二分查找-最坏o（log2n）
     * @des 有序数组，中间值，判断目标大于中间值则在右侧找，小于中间值则在左侧找，递归实现
     * @param array
     * @param target
     * @param left
     * @param right
     * @return
     */
    public  static  int  binarySearch(int[] array,int target,int left,int right){
        int mid=(right-left)/2+left;
        if(array[mid]==target){
            return mid;
        }
        if(left>=right){
            return -1;
        }
        if(target>array[mid]){
          return   binarySearch(array,target,mid+1,right);
        }
        if(target<array[mid]){
           return binarySearch(array,target,left,mid-1);
        }

        return  -1;
    }