牛客网算法笔记（基础班第一课）

一

一个有序数组A， 另一个无序数组B，请打印B中的所有不在A中的数， A数组长度为N，B数组长度为M。

算法流程1：对于数组B中的每一个数，都在A中通过遍历的方式找一下；

算法流程2：对于数组B中的每一个数，都在A中通过二分的方式找一下；

算法流程3：先把数组B排序，然后用类似外排的方式打印所有在A中出现的数；

​ 1、O(M*N)

​ 2、O(M*logN)

​ 3、O(M*logM)+O(M+N)

二

对数器的概念和使用(用这种思想来自我验证)
0， 有一个你想要测的方法a，
1， 实现一个绝对正确但是复杂度不好的方法b，
2， 实现一个随机样本产生器
3， 实现比对的方法
4， 把方法a和方法b比对很多次来验证方法a是否正确。
5， 如果有一个样本使得比对出错， 打印样本分析是哪个方法出错
6， 当样本数量很多时比对测试依然正确， 可以确定方法a已经正确
实现见下方代码

三

冒泡排序与复杂度分析

​ 每次都能找出一个最大或最小到最后一位
​ 时间复杂度O(N^2)， 额外空间复杂度O(1)

import java.util.Arrays;

public class BubbleSort{
    public static void bubbleSort(int arr[]){
        if (arr == null || arr.length < 2){
            //特殊情况
            return;
        }

        for (int e = arr.length - 1; e > 0; e--){
            for (int i = 0; i < e; i++){
                if (arr[i] > arr[i + 1]){
                    swap2(arr, i, i+1);
                }
            }
        }
    }
    public static void swap1(int arr[], int i, int j){
        //1.借助临时变量
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    public static void swap2(int arr[], int i, int j){
        //2.1 异或法 2.2加减法 2.3乘除法
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    //for test:
    public static void comparator(int arr[]){
        Arrays.sort(arr);
    }
    public static int[] generateRandomArray(int maxSize, int maxValue){
        int arr[] = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++){
            arr[i] = (int)((maxValue + 1) * Math.random()) - (int)((maxValue + 1) * Math.random());
        }
        return arr;
    }
    public static int[] copyArray(int arr[]){
        if(arr == null){
            return null;
        }
        int res[] = new int[arr.length];
        for(int i = 0; i < arr.length; i++){
            res[i] = arr[i];
        }
        return res;
    }
    public static boolean isEqual(int arr1[], int arr2[]){
        if((arr1 == null && arr2 != null) || (arr2 == null && arr1 != null)){
            return false;
        }
        if(arr1.length != arr2.length){
            return false;
        }
        if(arr1 == null && arr2 == null){
            return true;
        }
        for(int i = 0; i < arr1.length; i++){
            if(arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }
    public static void printArray(int arr[]){
        if(arr == null){
            return;
        }
        for(int x: arr){
            System.out.print(x + " ");
        }
        System.out.println();
    }
    public static void main(String args[]){
        int testTime = 50000;
        int maxSize = 100;
        int maxValue = 100;
        boolean succeed = true;
        for(int i = 0; i < testTime; i++){
            int arr1[] = generateRandomArray(maxSize, maxValue);
            int arr2[] = copyArray(arr1);
            bubbleSort(arr1);
            comparator(arr2);
            if(!isEqual(arr1, arr2)){
                succeed = false;
                break;
            }
        }
        System.out.println(succeed? "Nice!" : "Fucking fucked!");

        int arr[] = generateRandomArray(maxSize, maxValue);
        printArray(arr);
        bubbleSort(arr);
        printArray(arr);
    }

}

四

选择排序与复杂度分析
时间复杂度O(N^2)， 额外空间复杂度O(1)

import java.util.Arrays;

public class SelectionSort{
    public static void selectionSort(int arr[]){
        if (arr == null || arr.length < 2){
            return;
        }
        for (int i = 0; i < arr.length - 1; i++){
            minIndex = i;
            for (int j = i + 1; j < arr.length; j++){
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }
    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];
    }
}

五

插入排序与复杂度分析
分成两段，一段是排好的，一段是未排的（类似摸牌），有点像反向冒泡;
时间复杂度O(N^2)， 额外空间复杂度O(1).

import java.util.Arrays;

public class InsertionSort{
    public static void insertionSort(int arr[]){
        if (arr == null || arr.length < 2){
            return 0;
        }
        for (int i = 1; i < arr.length; i++){
            for(int j = i - 1; j >= 0 && arr[j] > arr[j+1]; j--){
                swap(arr, j, j + 1);
            }
        }
    }
    public static void swap(int arr[], int i, int j){
        if (arr == null || i > arr.length - 1 || j > arr.length - 1){
            return;
        }
        arr[i] = arr[i] * arr[j];
        arr[j] = arr[i] / arr[j];
        arr[i] = arr[i] / arr[j];
    }
}

六

剖析递归行为和递归行为时间复杂度的估算
一个递归行为的例子
master公式的使用(适用范围：子过程规模一样)
T(N) = a*T(N/b) + O(N^d)

1. log(b,a) > d -> 复杂度为O(N^log(b,a))
2. log(b,a) = d -> 复杂度为O(N^d * logN)
3. log(b,a) < d -> 复杂度为O(N^d)
   补充阅读： www.gocalf.com/blog/algorithm-complexity-and-mastertheorem.html
   先例：用递归求一个数组的最大值

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

public class Demo{
    public static int getMax(int[] arr, int L, int R){
        if(L == R){
            return arr[L];
        }

        int mid = (L + R) / 2;
        int leftMax = getMax(arr, L, mid);
        int rightMax = getMax(arr, mid+1, R);
        return Math.max(leftMax, rightMax);
    }
    public static void main(String[] args){
        int[] arr = new int[]{4,3,2,1};
        System.out.println(getMax(arr, 0, arr.length-1));
    }
}

七

归并排序的细节讲解与复杂度分析（递归）
（1）左侧和右侧分别排好序；
（2）用外排的方式同一排好。
跨组比较，每一次都利用了之前排过的序，不像冒泡和选择等重复比较
T(N) = 2T(n/2) + O(N)
时间复杂度O(N*logN)， 额外空间复杂度O(N)

public class MergeSort{
    public static void mergeSort(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        mergeSort(arr, 0, arr.length-1);
    }
    public static void mergeSort(int[] arr, int l, int r){
        if(l == r){
            return;
        }

        int mid = (l + r) / 2;
        // int mid = l + (r - l) / 2; //防止溢出
        // int mid = l + (r - 1) >> 1;  //等价于右移一位
        mergeSort(arr, l, mid);
        mergeSort(arr, mid+1, r);
        merge(arr, l, mid, r);
    }
    public static void merge(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 (int j = 0; j < help.length; j++){
            arr[l + j] = help[j];
        }
    }
}

八

小和问题和逆序对问题
小和问题
在一个数组中， 每一个数左边比当前数小的数累加起来， 叫做这个数组的小和。 求一个数组的小和。
例子：
[1,3,4,2,5]
1左边比1小的数， 没有；
3左边比3小的数， 1；
4左边比4小的数， 1、 3；
2左边比2小的数， 1；
5左边比5小的数， 1、 3、 4、 2；
所以小和为1+1+3+1+1+3+4+2=16
【思路】
1、暴力方法：每个数遍历左边，O(N^2)
2、归并排序方法
等价于当前数右边比这个数大的个数

逆序对问题
在一个数组中， 左边的数如果比右边的数大， 则折两个数构成一个逆序对， 请打印所有逆序
对。

public class SmallSum{
       public static int smallSum(int[] arr){
           if(arr == null || arr.length < 2){
               return 0;
           }
           return mergeSort(arr, 0, arr.length-1);
       }
       public static int mergeSort(int[] arr, int l, int r){
           if(l == r){
               return 0;
           }
           int mid = l + (r - l) / 2;
           return mergeSort(arr, l, mid) + mergeSort(arr, mid+1, r) + merge(arr, l, mid, r);
       }
       public static int merge(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;
       }
}