#每日一题合集#牛客JZ54-JZ64

为了督促自己每天练一练编程
时间：2022年9月21日-2022年9月30日
网站：https://www.nowcoder.com/exam/oj/ta?tpId=13

9.21-JZ54.二叉搜索树的第k个节点

递归中序遍历，当节点为空或者超过k时，结束递归。

class Solution {
public:
    TreeNode* res = NULL;
    int cnt = 0;
    void mid(TreeNode* root, int k){
        if(root == NULL || cnt > k)
            return;
        mid(root->left, k);
        cnt++;
        if(cnt == k)
            res = root;
        mid(root->right, k);

    }
    int KthNode(TreeNode* proot, int k) {
        // write code here
        mid(proot, k);
        if(res)
            return res->val;
        else
            return -1;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

9.22-JZ55.二叉树的深度

class Solution {
public:
    int TreeDepth(TreeNode* pRoot) {
		if(pRoot == NULL)
			return 0;
		return max(TreeDepth(pRoot->left), TreeDepth(pRoot->right)) + 1;
    }
};

1
2
3
4
5
6
7
8
9

9.23-JZ56.数组中只出现一次的两个数字

class Solution {
public:
    vector<int> FindNumsAppearOnce(vector<int>& array) {
        // write code here
        unordered_map<int, int> mp;
        vector<int> res;

        for(int i = 0; i < array.size(); i++){
            mp[array[i]]++;
        }
        for(int i = 0; i < array.size(); i++){
            if(mp[array[i]] == 1)
                res.push_back(array[i]);
        }
        sort(res.begin(), res.end());
        return res;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

9.24-JZ57.和为S的两个数字

因为是升序数组，所以直接双指针，首尾相加判断即可。

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        vector<int> res;
        int left = 0, right = array.size() - 1;
        while(left < right){
            if(array[left] + array[right] == sum){
                res.push_back(array[left]);
                res.push_back(array[right]);
                break;
            }
            else if(array[left] + array[right] > sum){
                right--;
            }
            else
                left++;
        }
        return res;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

9.25-JZ58.左旋转字符串

直接遍历拼接即可。

class Solution {
public:
    string LeftRotateString(string str, int n) {
        int m = str.length();
        if(m == 0)
            return "";
        n = n % m;
        string res = "";
        for(int i = n; i < m; i++)
            res += str[i];
        for(int i = 0; i < n; i++)
            res += str[i];
        return res;

    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

9.26-JZ59.滑动窗口的最大值

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        vector<int> res;
        int n = num.size();
        if(size <= n && size != 0){
            for(int i = 0; i <= n - size; i++){
                int max = 0;
                for(int j = i; j < i + size; j++){
                    if(num[j] > max)
                        max = num[j];
                }
                res.push_back(max);
            }
        }
        return res;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

9.27-JZ61.扑克牌顺子

主要判断两点，一个是数组内除了0以外，数字不能重复；二是，数字间隔不能超过0的个数。

class Solution {
public:
    bool IsContinuous( vector<int> numbers ) {
        sort(numbers.begin(), numbers.end());
        int zero = 0, i = 0, tmp = 0;
        while(numbers[i] == 0){
            i++;
            zero++;
        }
        for(;i < numbers.size()-1; i++){
            if(numbers[i] == numbers[i+1])
                return false;
            tmp += numbers[i + 1] - numbers[i] - 1;
        }
        if(zero >= tmp)
            return true;
        return false;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

9.28-JZ62.孩子们的游戏(圆圈中最后剩下的数)

class Solution {
public:
    int fun(int n, int m){
        if(n == 1)
            return 0;
        int x = fun(n - 1, m);
        return (m + x) % n;
    }
    int LastRemaining_Solution(int n, int m) {
        if(n == 0 || m == 0)
            return -1;
        return fun(n, m);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

9.29-JZ63.买卖股票的最好时机(一)

用dp[i][0]表示卖出股票(或者之前没买过)，dp[i][1]表示买入股票。
初始状态：第一天总收益为0，dp[0][0]=0；第一天要是买入的话，则总收益为买股票的花费，此时为负数，dp[0][1]=−prices[0]d
状态转移：
dp[i][0]可能是前面卖掉了或是还没买(总收益和前一天相同)，也有可能是当天才卖掉。dp[i][0]=max(dp[i−1][0],dp[i−1][1]+prices[i])；
dp[i][1]可能是前面买了股票(收益与前一天相同)，也有可能是当天买入，此时收益为负的股价。dp[i][1]=max(dp[i−1][1],−prices[i])。

class Solution {
  public:
    int maxProfit(vector<int>& prices) {
        // write code here
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];

        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = max(dp[i - 1][1], -prices[i]);
        }
        return dp[n - 1][0];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

9.30-JZ64.求1+2+3+…+n

第一反应，这不累加公式直接出吗（能过）

class Solution {
public:
    int Sum_Solution(int n) {
        return n * (n + 1) / 2;
    }
};
1
2
3
4
5
6

后面看了一眼题解，发现是位运算QWQ

class Solution {
public:
    int Sum_Solution(int n) {
        //通过与运算判断n是否为正数，以结束递归
        n && (n += Sum_Solution(n - 1));
        return n;
    }
};
1
2
3
4
5
6
7
8