LeetCode---2021/8/28

一维数组的动态和

方法一：
  前缀和。
代码：

class Solution {
public:
    vector<int> runningSum(vector<int>& nums) {
        int n = nums.size();
        vector<int> res(n);
        int sum = 0;
        for(int x : nums) {
            sum += x;
        }
        res[n - 1] = sum;
        for(int i = n - 2; i >= 0; i--) {
            res[i] = res[i + 1] - nums[i + 1];
        }
        return res;
    }
};

方法二：
  原地修改。
代码：

class Solution {
public:
    vector<int> runningSum(vector<int>& nums) {
        int n = nums.size();
        for (int i = 1; i < n; i++) {
            nums[i] += nums[i - 1];
        }
        return nums;
    }
};

只出现一次的数字 II

方法一：
  哈希表。
代码：

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        unordered_map<int, int> mp;
        for(int x : nums) {
            mp[x]++;
        }
        for(auto x : mp) {
            if(x.second == 1) {
                return x.first;
            }
        }
        return 0;
    }
};

方法二：
  位运算。设答案为ans，即在nums中ans只出现了一次。遍历每一个元素的第i位，由于除了ans以外所有数都出现了三次，所以数组中所有元素的第i位之和再模上3就是ans的第i位。
代码：

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ans = 0;
        for (int i = 0; i < 32; ++i) {  //遍历32位
            int total = 0;
            for (int num: nums) {
                total += ((num >> i) & 1);  //将每个元素的第i位求和
            }
            if (total % 3) {
                ans |= (1 << i);  //ans的第i位
            }
        }
        return ans;
    }
};

加油站

分析：
  循环判断每个位置是否满足要求。
代码：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int n = gas.size();
        for(int i = 0; i < n; i++) {
            int sum = 0, flag = 0;
            for(int j = i; j < i + n; j++) {
                int cur = j % n;
                sum += gas[cur];
                if(sum - cost[cur] < 0) {
                    flag = 1;
                    break;
                }
                sum -= cost[cur];
            }
            if(flag) {
                continue;
            }else {
                return i;
            }
        }
        return -1;
    }
};

二叉树的层平均值

分析：
  层序遍历。
代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        if(root == NULL) {
            return res;
        }
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int n = que.size();
            long long sum = 0;
            for(int i = 0; i < n; i++) {
                TreeNode* fr = que.front();
                que.pop();
                sum += fr->val;
                if(fr->left) {
                    que.push(fr->left);
                }
                if(fr->right) {
                    que.push(fr->right);
                }
            }
            double temp = sum / (n * 1.0);
            res.push_back(temp);
        }
        return res;
    }
};

平衡二叉树

分析：
  递归判断。
代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int getDepth(TreeNode* root) {
        if(root == NULL) {
            return 0;
        }
        return 1 + max(getDepth(root->left), getDepth(root->right));
    }
    bool isBalanced(TreeNode* root) {
        if(root == NULL) {
            return true;
        }
        return abs(getDepth(root->left) - getDepth(root->right)) <= 1 && isBalanced(root->left) && isBalanced(root->right);
    }
};

二叉树的最小深度

分析：
  深度优先搜索：见注释。
代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == NULL) {  //叶子结点返回
            return 0;
        }
        int left = minDepth(root->left);  //左子树根结点到叶子的最短距离
        int right = minDepth(root->right); //右子树根结点到叶子的最短距离
        if(left == 0 || right == 0) {  //有一个为0说明左右孩子必有一个是叶子结点
            return max(left, right) + 1;  //递归计算深度
        }
        return min(left, right) + 1;//返回
    }
};

移除链表元素

分析：
  遍历链表然后删除。
代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head == NULL) {
            return NULL;
        }
        ListNode* ptr = new ListNode(0, head);
        ListNode* res = ptr;
        while(ptr->next) {
            if(ptr->next->val == val) {
                ptr->next = ptr->next->next;
            }else {
                ptr = ptr->next;
            }
        }
        return res->next;
    }
};