22.1.7 master公式及O(NLogN)的排序

22.1.7 master公式及O(NLogN)的排序

1 master 公式

(1) 写公式

• T(N) = a * T(N/b) + O(N^d);

• master公式用来求递归行为的时间复杂度，式中T(N/b)表示母问题被分解为子问题的规模，a表示子问题被调用的次数，O(N^d)表示算法中其他过程的时间复杂度。

  例如：

  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);//mid = L+((R-L)/2),/2可以表示为右移一位。
      int leftMax = process(arr,L,mid);
      int rightMax = process(arr,mid,R);
      return Math.max(leftMax,rightMax);
  }

• 其中，T(N) = 2 * T(N/2) + O(1);a = 2,b = 2,d = 0;

（2）求时间复杂度：

• log以b为底a的对数 < d , 时间复杂度为O(N^d);

• log以b为底a的对数 > d , 时间复杂度为O(N^log以b为底a的对数);

• log以b为底a的对数 = d , 时间复杂度为O((N^d) * logN);

2 O(NLogN)的排序:

(1) 归并排序：

public static void main(String[] args)
    {
        int[] arr = {2,4,6,4,6,7,1,8,3,9,8};
        process(arr,0,arr.length-1);
        for(int cur:arr)
        {
            System.out.print(cur+" ");
        }
    }
​
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);
        mergeSoft(arr,L,mid,R);
    }
    
    public static void mergeSoft(int[] arr,int L,int M,int R)
    {
        int[] help = new int[R-L+1];
        int i=0;
        int p1 = L;
        int p2 = M+1;
        while(p1<=M && p2<=R)
        {
            help[i++] = arr[p1]<=arr[p2]?arr[p1++]:arr[p2++];
        }
        while(p1<=M)
            help[i++] = arr[p1++];
        while(p2<=R)
            help[i++] = arr[p2++];
        for(i=0;i<help.length;i++)
            arr[L+i] = help[i];
    }

example:小和问题，求逆序对

• 小和问题描述：对于一个数组例如，2,1,5,8,9,6,3,4。其中2和5,8,9,6,3,4都会产生小和2，同理1与5,8,9,6,3,4也都会产生小和1，依次累加所有的小和然后返回。

//小和问题
public static void main(String[] args)
    {
        int[] arr = { 2,1,5,8,9,6,3,4};
        int res = smallSum(arr);
        System.out.println(res+" ");
}
​
public static int smallSum(int[] arr)
    {
        if(arr == null || arr.length<2)
            return  -1;
        return process(arr,0,arr.length-1);
    }
    
    public static int process(int[] 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)+mergeSoft(arr,L,mid,R);
    }
    
    public static int mergeSoft(int[] arr,int L,int M,int R)
    {
        int[] help = 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;
            help[i++] = arr[p1]<=arr[p2]?arr[p1++]:arr[p2++];
        }
        while(p1<=M)
            help[i++] = arr[p1++];
        while(p2<=R)
            help[i++] = arr[p2++];
        for(i=0;i<help.length;i++)
            arr[L+i] = help[i];
        return res;
    }

（2) 快速排序

public static void main(String[] args)
    {
        int[] arr = { 2,1,5,8,9,6,3,4};
        quickSort(arr,0,(arr.length-1));
    }
        
    public static void swap(int[] arr ,int l,int r)
    {
        int temp = arr[r];
        arr[r] = arr[l];
        arr[l] = temp;
    }
    
    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])
            {
                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};
    }