秋招/春招常见笔试题目——数组系列(C/C++)

        大家好！下面是我(一个小小的搬运工)在秋招的时候在Leetcode上整理的一些与数组相关的题目（中等难度），笔试和面试考相似思路题目的概率比较大，大家如果准备春秋季招聘可以先根据这些题目复习(具体思路可以看Leetcode中的讲解——困难的题有链接)：

//https://blog.youkuaiyun.com/qq_41855420/column/info/38495    c++STL模板剖析


https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/solution/yi-ge-tong-yong-fang-fa-tuan-mie-6-dao-gu-piao-wen/
股票问题！！！


/*

最大堆——子节点的值比父节点的值都要小，即根节点为最大值。（大根堆）

最小堆——子节点的值比父节点的值都要大，即根节点为最小值。（小根堆）




最大堆和最小堆问题：
1、multimap<int, int, std::greater<int>> freq;//   (less<int>)最小堆  (greater<int>)最大堆    与make_heap()正好相反

2、multiset<int, less<int> > res;             //   (less<int>)最小堆  (greater<int>)最大堆    与make_heap()正好相反



3、priority_queue<double,greater<double>>     //    最小堆

4、    
	make_heap(nums.begin(), nums.end(), less<int>());       //创建最大堆
	make_heap(nums.begin(), nums.end(), greater<int>());    //创建最小堆

	//https://www.jianshu.com/p/13a56502e217


*/

//2019_05_09
//1、给定一个未排序的数组，在O(n)的时间复杂度内找到其最大连续子串的长度
Given[100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is[1, 2, 3, 4]. Return its length:4.
//用散列表，首先将数字都映射到散列表上，然后，对于每个数字，找到后就删除，然后向两边
//同时搜，只要搜到了就删除，最后求出长度。哈希表搜是O(1),因为每个数字只会添加一次，
//删除一次，所以复杂度是O（n）
class Solution {
public:
    int longestConsecutive(vector<int> &num) {
            unordered_set<int> st(num.begin(),num.end());
            int ans=0;
            for(auto v:num){       //c++11新特性，v表示num迭代器中的每一个
                if(st.find(v)==st.end()) continue;
                int l=v,r=v;
                st.erase(v);
                while(st.find(r+1)!=st.end()) st.erase(++r);
                while(st.find(l-1)!=st.end()) st.erase(--l);
                ans=max(r-l+1,ans);
            }
            return ans;
    }
};
/**
动态规划问题：  (1)将问题分解成子问题(2)找出状态转移方程(3)求出边界条件！！！！！
**/
//2、卖股票问题（给定一个数组，表示每天股票的价格，可以无数次交易(先买再卖)，求最大利润）
//有买(buy)和卖(sell)两种状态
//若当天买股票，则损失-prices[i],若卖股票，则增加prices[i]
//那么当天卖出去的总收益为buy+prices[i]
// 需要考虑（1）：当天买和之前买哪个损失少，即buy是负数 （2）：当天卖和之前卖哪个收益高，即sell是正数
// 状态转移方程： sell=max(sell,buy+prices[i])   buy=max(buy,sell-prices[i])



class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if(prices.size()==0)
            return 0;
        int buy=-prices[0],sell=0;
        for(int i=0;i<prices.size();i++)
        {
            sell=max(sell,prices[i]+buy);
            buy=max(buy,sell-prices[i]);
            
        }
        return sell;
    }
};

//3、
/*
 * 给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。
 * 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
 * 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
 */
 /**
     * 使用两个游标i，j，遍历数组，如果碰到了value，使用j记录位置，同时递增i，
     * 直到下一个非value出现，将此时i对应的值复制到j的位置上，增加j，重复上述
     * 过程直到遍历结束。这时候j就是新的数组。比如数组为1，2，2，3，2，4，删除
     * 2，首先初始化i和j为0，指向第一个位置，因为第一个元素为1，
     * 所以A[0] = A[0]，i和j都加1，而第二个元素为2，我们递增i，直到碰到3，
     * 此时v[1] = v[3]，也就是3，递增i和j，这时候下一个元素又是2，递增i，直
     * 到碰到4，此时v[2] = v[5]，也就是4，再次递增i和j，这时候数组已经遍历完
     * 毕，结束。这时候j的值为3，刚好就是新的数组的长度。
     *
     **/
class Solution {
public:
    int removeElement(int A[], int n, int elem) {
        if(n==0)
            return 0;
        int i=0,j=0;
        for(i=0;i<n;i++)
        {
            if(A[i]==elem)
                continue;
            A[j++]=A[i];
            
        }
        return j;
    }
};

//2019_05_13
//1、找到两个排序数组中的中位数（可以扩展为寻找第k小数）
//There are two sorted arrays A and B of size m and n respectively. Find the median of the two sorted arrays. 
//The overall run time complexity should be O(log (m+n))
/*
链接：https://www.nowcoder.com/questionTerminal/82c11b9392b14f3abfbf257f79a76025
来源：牛客网

要求在O(log (m+n))时间内找到中位数，所以像那些合并之后再二分查找、或者一边比较一边合并到总量一半的方法肯定是不行的。

我们可以将原问题转变成一个寻找第k小数的问题（假设两个原序列升序排列），这样中位数实际上是第(m+n)/2小的数。所以只要解决了第k小数的问题，原问题也得以解决。

首先假设数组A和B的元素个数都大于k/2，我们比较A[k/2-1]和B[k/2-1]两个元素，这两个元素分别表示A的第k/2小的元素和B的第k/2小的元素。这两个元素比较共有三种情况：>、<和=。如果A[k/2-1] < B[k/2-1]，这表示A[0]到A[k/2-1]的元素都在A和B合并之后的前k小的元素中。换句话说，A[k/2-1]不可能大于两数组合并之后的第k小值，所以我们可以将其抛弃。

当A[k/2-1]=B[k/2-1]时，我们已经找到了第k小的数，也即这个相等的元素，我们将其记为m。由于在A和B中分别有k/2-1个元素小于m，所以m即是第k小的数。(这里可能有人会有疑问，如果k为奇数，则m不是中位数。这里是进行了理想化考虑，在实际代码中略有不同，是先求k/2，然后利用k-k/2获得另一个数。)

通过上面的分析，我们即可以采用递归的方式实现寻找第k小的数。此外我们还需要考虑几个边界条件：

如果A或者B为空，则直接返回B[k-1]或者A[k-1]；
如果k为1，我们只需要返回A[0]和B[0]中的较小值；
如果A[k/2-1]=B[k/2-1]，返回其中一个
*/
class Solution {
public:
    double findMedianSortedArrays(int A[], int m, int B[], int n) {

        int total = m + n;
        if(total & 0x1)
            return findKth(A, m, B, n, total / 2 + 1);
        else
            return (findKth(A, m, B, n, total/2)
                   + findKth(A, m, B, n, total / 2 + 1)) / 2;
    }
double findKth(int A[], int m, int B[], int n, int k){
        if(m > n)
            return findKth(B, n, A, m, k);  //始终保持元素较少的数组位于前面的位置
        if(m == 0)
            return B[k-1];                  //如果位于前面的数组为空，则直接返回后面数组的第k-1个元素
        if(k == 1)
            return min(A[0], B[0]);         //如果k等于1，则返回两个数组头元素的最小值
 
        int pa = min(k / 2, m), pb = k - pa;
        if(A[pa-1] < B[pb-1])
            return findKth(A + pa, m - pa, B, n, k - pa);
        else if(A[pa - 1] > B[pb - 1])
            return findKth(A, m, B + pb, n - pb, k - pb);
        else
            return A[pa-1];
    }
    
};

//2、翻转一个整数(要考虑正负号、小数、溢出等情况)

//本体关键点是如何判断溢出。
//推荐解答用的是用long类型存储结果，如果结果大于0x7fffffff或者小于0x80000000就溢出

//当res*10+tail的值超过最大位数时，系统会将超过最大位数的高位二进制数扔掉，从而导致了newRes!=res*10+tail.
//此时计算的(newRes-tail)/10自然也不等于res了。

class Solution {
public:
    int reverse(int x)
    {
        int res=0;
        while(x!=0){
            //最后一位
            int tail=x%10;
            int newRes=res*10+tail;
            //如果newRes-tail)/10!=res说明产生了溢