左程云算法课程学习笔记（二）-认识O(NlogN)的排序

认识O(NlogN)的排序

• 剖析递归行为和递归行为时间复杂度的估算

  用递归方法去寻找一个数组中的最大值，系统上到底是怎么做的？

  补充知识：双目运算符">>",指的是右移一位，是以二进制计算，右移就是在右后加零在前面减去移动的位数个数，经过计算，右移一位就是除2，左移一位就是乘2。此操作比除法快。

  //在数组[L,.....,R]范围寻找最大值
  public static int getMax(int[] arr){
      return process(arr,0,arr.length-1);
  }
  public static int process(int[] arr,int L,int R){
  	if(L==R){
          return arr[L];
      }
      int mid=L+((R-L) >> 1);//中点
      int leftMax=process(arr,L,mid);
      int rightMax=process(arr,mid+1,R);
      return Math.max(leftMax,rightMax);
  }
  //递归行为在系统上如何实现
  

​ 依次压栈进栈，返回左右结果。利用栈，进行一个后序遍历。

• master公式的使用

  用来估计一系列特殊的递归行为的方法，是用来利用分治策略来解决问题经常使用的时间复杂度的分析方法，（补充：分治策略的递归解法还有两个常用的方法叫做代入法和递归树法，以后有机会和亲们再唠），众所周知，分治策略中使用递归来求解问题分为三步走，分别为分解、解决和合并，主方法的表现形式：

  T [N] = aT[N/b] + O (N^d)

  ​ 母问题的数据量为N,每一次子过程的规模等量为N/b,调用次数为a，最后是除去调用的子问题之外剩下的过程的时间复杂度。

• 分析系统递归行为

  T（N）是总的，子问题规模是N/2，其余的子问题数据等规模，调用了2次，最后的比大小行为时间复杂度为O(1)。满足这类条件的算法满足master公式。

  T(N)=2T(N/2)+O(1)

  如果满足master公式的递归排序，时间复杂度为下

  条件	时间复杂度
  logba<d	O(Nd)
  logba>d	O(Nlogba)
  logba==d	O(Nd *logN)

  经过代值计算,系统的递归行为，a=2,b=2,d=1得时间复杂度为O(N)，等效于从左到右遍历一遍求最大值。

• 归并排序

  ​ 一个无序数组，先从中间分离开，分别排序分开的两个数组，在左边的数组第一位标记，在右边的数组第一位，分别对比其大小，定义规则，假设从小到大，左侧标记位小于右侧标记位，则创建一个临时数组将左侧的数储存，将左侧标记向右移动一位，若是右侧标记小，则将右侧标记数放入临时数组，右侧标记向右移动一位，此过程中，若是左右有任意一侧标记越位，则将另一侧数组中的剩下的内容放入临时数组，再将临时数组的值定义给原数组。

  public static void process(int[] arr,int L,Int R){
      if(L==R){
          return;
      }
      int mid=L+((R-L)>>1);
      process(arr,L,mid);
      process(arr,mid+1,R);
      merge(arr,L,mid,R);
  }
  public static void merge(int[] arr,int L,int M,int R){
      int[] temp=new int[R-L+1];
      int i=0;
      int p1=L;
      int p2=M+1;
      while(p1<=M && p2<=R){
          temp[i++]=arr[p1]<=arr[p2] ? arr[p1++]:arr[p2++];
      }
      while(p1<=M){
          temp[i++]=arr[p1++];
      }
      while(p2<=R){
          temp[i++]=arr[p2++];
      }
      for(i=0;i<temp.length;i++){
          arr[L+i]=temp[i];
      }
  }//排序合并过程
  

  T(N)=2T(N/2)+O(N) a=2 b=2 d=1

  O(N *logN)

  O(N2)比O(N *logN)差在了多余的比较，比如选择排序，浪费了很多比较，每次只排序一个。

• 归并排序的拓展

  小和问题：一个数组中，找该位置左边比他小的数，有几个，整个数组的小和就是每个位置的小和相加。暴力解法O(N²)

  merge进行运算：

  public static int smallSum(int[] arr){
      if(arr===null || arr.length<2){
          return 0;
      }
      return process(arr,0,arr.length-1);
  }
  public static int process(intp[] arr,int l,int r){
      if(l==r){
          return 0;
      }
      int mid=l+((r-l)>>1);
      return process(arr,l,mid)
          +process(arr,mid+1,r)
      +merge(arr,l,mid,r);
  }
  public static int merge(int[] arr,int L,int m,int r){
      int[] temp=new int[r=L+1];
      int i=0;
      int p1=L;
      int p2=m+1;
      int res=0;
      while(p1<=m && p2<=r){
          res+=arr[p1]<arr[p2] ? (r-p2+1)*arr[p1]:0;
          temp[i++]=arr[p1]<arr[p2] ? arr[p1++]:arr[p2++];
      }
      while(p1<=m){
          temp[i++]=arr[p1++];
      }
      while(p2<=r){
          temp[i++]=arr[p2++];
      }
      for(i=0;i<temp.length;i++){
          arr[L+i]=temp[i];
      }
      return res;
  }
  

• 快速排序

  问题1：给定一个数组arr，和一个数num，请把小于等于num的数放在数组的左边，大于num的数放在数组右边，中间是等于的数，要求额外空间复杂度O(1),时间复杂度O(N)。（荷兰国旗问题）

  public static void quickSort(int[] arr,int L,int R){
      if(L<R){
          swap(arr,L+(int)(Math.random()*(R-L+1)),R);
          int[] p=partition(arr,L,R);
          quickSort(arr,L,p[0]-1);//<区
          quickSort(arr,p[1]+1,R);//>区
      }
  }
  public static int[] partition(int[] arr,int L,int R){
      int less=L-1; //<区右边界
      int more=R; //>区左边界
      while(L<more){
          if(arr[L]<arr[R]){//L表示当前属的位置arr[R] ->划分值
              swap(arr,++less,L++);
          }else if(arr[L]>arr[R]){//当前数<划分值
              swap(arr,--more,L);
          }else{
              L++;
          }
      }
      swap(arr,more,R);
      return new int[] {less+1,more};
  }
  public static void swap(int[] arr,int i,int j){
      arr[i]=arr[i]^arr[j];
      arr[j]=arr[i]^arr[j];
      arr[i]=arr[i]^arr[j];
  }