春招秋招个人总结（左神算法、牛客网算法、Java后台面试等）

开心一下，已经顺利毕业了！想起去年的这个时候，自己也在为找实习、找工作，而拼命刷算法、刷面经。最近几天闲来无事，于是，决定将之前购买的和自己收集的算法课程（主要包括“算法面试笔试视频资料”和“java后台开发面试视频资料”），整理了一下，做个总结，希望可以帮助到正在找工作的同学。收集和整理的课程资料大致如下所示，个人比较推荐的资料是“LeetCode 刷题”、“通关40讲”、“左程云的BAT算法”、“左程云的高频精讲”、“左程云的基础和进阶算法”、“剑指java面试”、“Java 校招面试 google面试官亲授”，“牛客网叶神的项目”！

1. 《牛客网 左程云 (初级、进阶)算法》
2. 《面试算法LeetCode刷题班》
3. 《玩转算法面试 leetcode题库分门别类详细解析》
4. 《九章算法系列课程》
5. 《牛客网 算法高频题目精讲(左程云)》
6. 《牛客网-直通BAT算法精讲(左程云)》
7. 《牛客网 初中高级项目(叶神)》
8. 《九章《动态规划》系列》
9. 《算法面试通关40讲》
10. 《剑指Java面试-Offer直通车》、《Java 校招面试 Google 面试官亲授》
11. 《面试算法10月份推荐》、《编程算法基础（JAVA版）》、《邓俊辉-算法训练营(第二期)》
12. 《Java秒杀系统方案优化 高性能高并发实战》、《Java从零到企业级电商项目实战》、《Spring Boot带前后端 渐进式开发企业级博客系统》、《Java并发编程与高并发解决方案(完整无密)》

第一节课 

第一题：题意与leetcode354的问题相同

算法原型 最长递增子序列问题

/*
 * 题意：求出给定序列的最长递增子序列的长度，给定序列不是有序的，子序列不是子数组，元素在原数组中不必是连续的
 * 
 */
/*
 * solutions1: 时间复杂度O(n^2),空间复杂度O(n)
 * 新建一个辅助数组h,h[i]表示以nums[i]结尾的最长递增子序列的长度
 * h[i]值的确定，需要nums[i]与nums[j](0<=j= num) {
                int pos = getPos(h, left, mid - 1, num);
                if (pos == -1)
                    return mid;
                return pos;
            } else {
                return getPos(h, mid + 1, right, num);                
            }            
        }
        return -1;
    }
    public static void main(String[] args){
        LongestSubSequence l = new LongestSubSequence();
        int[]  nums = {1,3,6,7,9,4,10,5,6};
        l.getLonggestLen(nums);
    }
}

回归到本题的解法

import java.util.Arrays;
import java.util.Comparator;
/*
 * 题意：CackingCodingInterview上的叠罗汉问题，leetcode上的沙皇问题
 *         将最长递增子序列扩展到了二维
 */
/*
 * solutions : 时间复杂度O(n+n*log(n)+n*log(n)) 也就是n*log(n) 
 * 目标是将二维数组抽象成一维数组，再利用解最长递增子序列的解法来解决这个问题
 * 首先我们需要将二维数组排序，排序策略是先按照array[i][0]排序，在array[i][0]相同的情况下，按照array[i][1]倒序排序
 * 为了排序我们可将array抽象成一个类A，二元组的两个元素分别是这个类A的两个成员变量
 * 将array转化为A的数组，给A自实现一个排序函数（按照上面的排序策略）
 * 接下来就转化为了最长递增子序列问题，将类A数组的h成员变量看作之前的一维数组就好了
 */
public class Leetcode354 {
    public int maxEnvelopes(int[][] envelopes) {
        if (envelopes.length < 2)
            return envelopes.length;
        A[] a = new A[envelopes.length];
        for (int i = 0; i < envelopes.length; i++) {
            a[i] = new A(envelopes[i][0],envelopes[i][1]);
        }
        Arrays.sort(a,new Comparator(){
            @Override
            public int compare(A a, A b) {
                if (a.w > b.w) {
                    return 1;
                } else if (a.w < b.w) {
                    return -1;
                } else {
                    if (b.h > a.h) {
                        return 1;
                    } else if (b.h < a.h) {
                        return -1;
                    } else
                        return 0;
                }
            }
        });        
        int maxLen = 0;
        int[] h = new int[envelopes.length];
        h[0] = a[0].h;
        for (int i = 1; i < envelopes.length; i++) {
            int pos = getPos(h, 0, maxLen - 1,a[i].h);
            if (pos == -1) {
                h[maxLen++] = a[i].h;                
            } else 
                h[pos] = a[i].h;
        }        
        return maxLen;
    }
    public int getPos(int[] h, int left, int right, int num) {
        if (left <= right) {
            int mid = left + (right - left) / 2;
            if (h[mid] >= num) {
                int pos = getPos(h, left, mid - 1, num);
                if (pos == -1)
                    return mid;
                return pos;
            } else {
                return getPos(h, mid + 1, right, num);                
            }            
        }
        return -1;
    }
    public static void main(String[] args){
        Leetcode354 l = new Leetcode354();
        int [][] envelopes = {{5,1},{6,4},{6,7},{2,3}};
        l.maxEnvelopes(envelopes);
    }
    
}
class A {
    int w = 0;
    int h = 0;
    public A(int w, int h) {
        this.w = w;
        this.h = h;
    }
}

 第二题

/*
 * 题意：详见2016 《牛课堂第一节课课件.pdf》第2题，leetcode42原题
 */
/*
 * solution1:时间复杂度 O(n) 空间复杂度O(n)
 * 首先简化一下题意：如果能求得当前位置格子上的水量，那么总水量就是每个位置水量之和
 * 当前格子上所能存储的水量 = 当前格子左边最大值与右边最大值之间的较小值 - 当前格子高度
 * 所以要先求出当前格子左边的最大值与右边最大值，对于右边最大值用数组r来辅助存储，从右往左遍历一下原数组即可得到r
 * 对于左边的最大值在遍历原数组的同时用一个全局变量记录下来就行，此时时间复杂度为O(n) 空间复杂度O(n)，还没达到最优解
 * 
 * solution2:时间复杂度 O(n) 空间复杂度O(1)
 * 为了不使用辅助数组，我们采用双指针的方法
 * 双指针left和right分别指向数组的第二个元素和倒数第二个元素，由题意可知第一个元素和最后一个元素的储水量都是零
 * 当前元素的遍历则从第二个和倒数第二个元素开始，用leftMax和rightMax分别记录左边最大值和右边最大值，用一个全局变量totalWater 更新总的储水量
 * 若leftMax < rightMax则结算左指针height[left]，leftMax > height[left]时，totalWater += leftMax - height[left++]，反之更新左边最大值leftMax = height[left++]，左指针向右移一位;
 * 反之，结算右边的当前元素，过程与左边类似 
 */
public class Question1 {
    public int getWater(int[] height){
        if (height == null || height.length < 3)
            return 0;
        int totalWater = 0;
        int left = 1, right = height.length - 2;
        int leftMax = height[0], rightMax = height[height.length - 1];
        while (left <= right) {
            if (leftMax < rightMax) {
                if (leftMax > height[left]) {
                    totalWater += leftMax - height[left++] ;
                } else {
                    leftMax = height[left++];
                }
            } else {
                if (rightMax > height[right]) {
                    totalWater += rightMax - height[right--] ;
                } else {
                    rightMax = height[right--];
                }                
            }
        }
        return totalWater;
    }
    public static void main(String[] args){
        Question1 q = new Question1();
        int[] height = {0,1,0,2,1,0,1,3,2,1,2,1}; 
        q.getWater(height);
    }
}

第三题

/*
 * 题意：详见2016 《牛课堂第一节课课件.pdf》第3题，leetcode11原题，找两个边界来装最多的水
 */
/*
 * solution ： 时间复杂度 O(n) 空间复杂度O(1)
 * 还是利用双指针left和right分别指向第一个元素和最后一个元素
 * 每次移动双指针中较小者，并更新最大装水量
 */
public class Question2 {
    public int maxArea(int[] height) {
        if (height == null || height.length < 2)
            return 0;
        int left = 0, right = height.length - 1;
        int max = 0;
        while (left <= right) {
            //用这句比较慢
//            max = Math.max(max, (right-left)*Math.min(height[left], height[right]));
            if (height[left] < height[right]) {
                int cur = height[left] * (right - left);
                max = max > cur ? max : cur;
                left++;
            } else {
                int cur = height[right] * (right - left);
                max = max > cur ? max : cur;
                right--;                
            }            
        }
        return max;
    }    
}