LeetCode 热题 100 (尽量ACM模式刷) 持续更新！！！

LeetCode 热题 100
哈希hash
1 两数之和

/*
 * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。
 * 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
 * 你可以按任意顺序返回答案。
 */
#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;

vector<int> twoSum(vector<int>& nums, int target)
{
    unordered_map<int, int> map;
    for (int i = 0; i < nums.size(); i++)
    {
        auto iter = map.find(target - nums[i]);
        if (iter != map.end()) {
            return {iter->second, i};
        }
        map.insert(pair<int, int>(nums[i], i));
    }
    return {};
}

int main()
{
    vector<int> nums = {2, 7, 11, 15};
    int target = 0;
    cin >> target;
    vector<int> result = twoSum(nums, target);
    for (auto a : result) {
        cout << a << ' ';
    }
    return 0;
}

2 字母异位词分组
思路：由于互为字母异位词的两个字符串包含的字母相同，因此对两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。

/*
 * 给你一个字符串数组，请你将字母异位词组合在一起。可以按任意顺序返回结果列表。
 * 字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
 */

#include <string>
#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>

using namespace std;
vector<vector<string>> groupWord(vector<string>& strs) {
    unordered_map<string, vector<string>> map;
    for (auto a : strs) {
        string key = a;
        sort(key.begin(), key.end());
        map[key].emplace_back(a);
    }
    vector<vector<string>> ans;
    for (auto iter = map.begin(); iter != map.end(); iter++) {
        ans.emplace_back(iter->second);
    }
    return ans;
}
int main()
{
    vector<string> s = {"eat", "tea", "tan", "ate", "nat", "bat"};
    vector<vector<string>> result = groupWord(s);
    for (auto a : result) {
        for (auto b : a) {
            cout << b << ' ';
        }
        cout << endl;
    }
    return 0;
}

复杂度分析
（1）时间复杂度：$O(nklog(k))$
（2）空间复杂度：$O(nk)$
3 最长连续序列

/*
 * 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
 * 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
 */
#include <iostream>
#include <unordered_set>
#include <vector>

using namespace std;
int longestS(vector<int>& nums) {
    int res = 0;
    int subLength = 0;
    unordered_set<int> nums_set(nums.begin(), nums.end());
    for (auto num : nums_set) {
        if (!nums_set.count(num - 1)) {
            subLength = 1;
            while (nums_set.count(++num)) subLength++;
            res = max(res, subLength);
        }
    }
    return res;
}

int main()
{
    vector<int> nums = {100,4,200,1,3,2};
    cout << longestS(nums) << endl;
    return 0;
}

双指针
1 移动零

/*
 * 给定一个数组nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。
 * 请注意 ，必须在不复制数组的情况下原地对数组进行操作。
 */
#include <iostream>
#include <vector>

using namespace std;
void moveZeros(vector<int>& nums) {
    int slow = 0;
    for (int fast = 0; fast < nums.size(); fast++) {
        if (nums[fast] != 0) {
            swap(nums[slow++], nums[fast]);
        }
    }
}
int main()
{
    vector<int> nums = {0,1,0,3,12};
    moveZeros(nums);
    for (auto i : nums) {
        cout << i << ' ';
    }
    return 0;
}

2 盛最多水的容器

/*
 * 给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
 * 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
 * 返回容器可以储存的最大水量。
 * 说明：你不能倾斜容器。
 */
#include <iostream>
#include <limits>
#include <vector>
using namespace std;

int maxArea(vector<int> heights) {
    int left = 0;
    int right = heights.size() - 1;
    int res = INT_MIN;
    while (left < right) {
        if (heights[left] < heights[right]) {
            res = max(res, (right - left) * heights[left]);
            left++;
        } else {
            res = max(res, (right - left) * heights[right]);
            right--;
        }
    }
    return res;
}
int main()
{
    vector<int> heights = {1,8,6,2,5,4,8,3,7};
    cout << maxArea(heights) << endl;
    return 0;
}

3 三数之和

/*
 * 给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
 * 你返回所有和为 0 且不重复的三元组。
 * 注意：答案中不可以包含重复的三元组。
 */
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> result;
    sort(nums.begin(), nums.end());
    for (int i = 0; i < nums.size(); i++) {
        if (nums[i] > 0) return result;
        if (i > 0 && nums[i] == nums[i - 1]) continue;
        int left = i + 1;
        int right = nums.size() - 1;
        while (left < right) {
            if (nums[i] + nums[left] + nums[right] > 0) right--;
            else if (nums[i] + nums[left] + nums[right] < 0) left++;
            else {
                result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                while (left < right && nums[left] == nums[left + 1]) left++;
                while (left < right && nums[right] == nums[right - 2]) right--;
                left++;
                right--;
            }
        }
    }
    return result;
}

int main()
{
    vector<int> nums = {-1,0,1,2,-1,-4};
    vector<vector<int>> res = threeSum(nums);
    for (auto a : res) {
        for (auto b : a) {
            cout << b << ' ';
        }
        cout << endl;
    }
}

4 接雨水

/*
 * 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
 */
#include <iostream>
#include <vector>

using namespace std;

int trap(vector<int>& height) {
    int sum = 0;
    for (int i = 0; i < height.size(); i++) {
        if (i == 0 || i == height.size() - 1) continue;
        int left = height[i];
        int right = height[i];
        for (int j = i - 1; j >= 0; j--) {
            if (left < height[j]) left = height[j];
        }
        for (int j = i + 1; j < height.size(); j++) {
            if (right < height[j]) right = height[j];
        }
        int h = min(left, right) - height[i];
        if (h > 0) sum += h;
    }
    return sum;
}
int main()
{
    vector<int> height = {0,1,0,2,1,0,1,3,2,1,2,1};
    cout << trap(height) << endl;
    return 0;
}

二叉树
1 二叉树的中序遍历

class Solution {
public:
    void traversal(TreeNode* node, vector<int>& vec) {
        if (node == NULL) return;
        if (node->left) traversal(node->left, vec);
        vec.push_back(node->val);
        if (node->right) traversal(node->right, vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

2 二叉树的最大深度
递归法：

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

迭代法：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        queue<TreeNode*> que;
        que.push(root);
        int depth = 0;
        while (!que.empty()) {
            int size = que.size();
            depth++;
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

3 翻转二叉树

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);
        if (root->left) invertTree(root->left);
        if (root->right) invertTree(root->right);
        return root;
    }
};

4 对称二叉树

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        if (left != NULL && right == NULL) return false;
        else if (left == NULL && right != NULL) return false;
        else if (left == NULL && right == NULL) return true;
        else if (left->val != right->val) return false;
        bool outside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        return outside && inside;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};

5 二叉树的直径

class Solution {
public:
    int ans;
    int depth(TreeNode* node) {
        if (node == NULL) return 0;
        int left = depth(node->left);
        int right = depth(node->right);
        ans = max(ans, left + right + 1);
        return max(left, right) + 1;
    }
    int diameterOfBinaryTree(TreeNode* root) {
        ans = 1;
        depth(root);
        return ans - 1;
    }
};

6 二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if (root == NULL) return result;
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

7 将有序数组转换为二叉搜索树

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left > right) return NULL;
        int mid = left + (right - left) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = traversal(nums, left, mid - 1);
        root->right = traversal(nums, mid + 1, right);
        return root;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = traversal(nums, 0, nums.size() - 1);
        return root;
    }
};

8 验证二叉搜索树

class Solution {
public:
    long long maxVel = LONG_MIN;
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;
        bool left = isValidBST(root->left);
        if (root->val > maxVel) maxVel = root->val;
        else return false;
        bool right = isValidBST(root->right);
        return left && right;
    }
};

9 二叉搜索树中第K小的元素

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

    }
    int kthSmallest(TreeNode* root, int k) {
        this->k = k;
        traversal(root);
        return res;
    }
};

10 二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> result;
        if (root == NULL) return result;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == (size - 1)) result.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

11 二叉树展开为链表

class Solution {
public:
    void traversal(TreeNode* node) {
        if (node == NULL) return;
        traversal(node->left);
        traversal(node->right);
        TreeNode* L = node->left;
        TreeNode* R = node->right;
        node->left = NULL;
        node->right = L;
        while (node->right != NULL) node = node->right;
        node->right = R;
        return;
    }
    void flatten(TreeNode* root) {
        if (root == NULL) return;
        traversal(root);
        return;
    }
};

12 从前序与中序遍历序列构造二叉树

// 前序遍历的第一个元素得到当前树的根节点
// 在中序遍历得到根节点分割的左右子树
// 通过得到的左右子树就是递归则问题
class Solution {
public:
    TreeNode* buildT(vector<int>& preorder, vector<int>& inorder, int prel, int prer, int inl, int inr) {
        if (prel > prer) return NULL;
        int rootVal = preorder[prel];
        TreeNode* root = new TreeNode(rootVal);
        int i = inl;
        for (i = inl; i <= inr; i++) {
            if (inorder[i] == rootVal) break;
        }
        int count = i - inl;
        root->left = buildT(preorder, inorder, prel + 1, prel + count, inl, inl + count - 1);
        root->right = buildT(preorder, inorder, prel + count + 1, prer, inl + count + 1, inr);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int r = preorder.size() - 1;
        return buildT(preorder, inorder, 0, r, 0, r);
    }
};

13 二叉树中的最大路径和

class Solution {
public:
    int ans = INT_MIN;
    int dfs(TreeNode* root) {
        if (root == NULL) return 0;
        ans = max(ans, root->val);
        int lsum = dfs(root->left);
        int rsum = dfs(root->right);

        lsum = max(0, lsum); rsum = max(0, rsum);
        ans = max(ans, root->val + lsum + rsum);
        return max(root->val + lsum, root->val + rsum);
    }
    int maxPathSum(TreeNode* root) {
        ans = max(ans, dfs(root));
        return ans;
    }
};

14 二叉树的最近公共祖先

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == p || root == NULL || root == q) return root;
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if (left != NULL && right != NULL) return root;
        if (left == NULL && right != NULL) return right;
        return left;
    }
};

15 路径总和 III

class Solution {
public:
    int dfs(TreeNode* root, long target) {
        if (root == NULL) return 0;
        int count = 0;
        if (root->val == target) count++;
        count += dfs(root->left, target - root->val);
        count += dfs(root->right, target - root->val);
        return count;
    }
    int pathSum(TreeNode* root, int targetSum) {
        if (root == NULL) return 0;
        int res = dfs(root, targetSum);
        res += pathSum(root->left, targetSum);
        res += pathSum(root->right, targetSum);
        return res;
    }
};

二分法
1 搜索插入位置

/**
** 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
 * 请必须使用时间复杂度为 O(log n) 的算法。
*/
#include <iostream>
#include <vector>

using namespace std;

int searchInsert(vector<int>& nums, int target)
{
    int left = 0;
    int right = nums.size() - 1;
    int ans = nums.size();
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] >= target) {
            right = mid - 1;
            ans = mid;
        } else {
            left = mid + 1;
        }
    }
    return ans;
}
int main()
{
    vector<int> nums = {1,3,5,6};
    int target = 0;
    cin >> target;
    cout << searchInsert(nums, target);
    return 0;
}

2 搜索二维矩阵

/**
** 给你一个满足下述两条属性的 m x n 整数矩阵：
 * 每行中的整数从左到右按非严格递增顺序排列。
 * 每行的第一个整数大于前一行的最后一个整数。
 * 给你一个整数 target ，如果 target 在矩阵中，返回 true ；否则，返回 false 。
*/
#include <iostream>
#include <vector>
using namespace std;

bool searchTwoMatrix(vector<vector<int>>& matrix, int target) {
    int m = matrix.size();
    int n = matrix[0].size();
    int left = 0;
    int right = m * n - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        int x = matrix[mid / n][mid % n];
        if (x > target) {
            right = mid - 1;
        } else if (x < target) {
            left = mid + 1;
        } else return true;
    }
    return false;
}
int main()
{
    vector<vector<int>> matrix = {{1, 3, 5, 7},
                                  {10,11,16,20},
                                  {23,30,34,60}};
    int target = 0;
    cin >> target;
    cout << searchTwoMatrix(matrix, target) << endl;
}

3 在排序数组中查找元素的第一个和最后一个位置

/**
* 给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
 * 如果数组中不存在目标值 target，返回 [-1, -1]。
 * 你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
*/
#include <iostream>
#include <vector>

using namespace std;
vector<int> searchRange(vector<int>& nums, int target) {
    if (nums.empty()) return vector<int>{-1, -1};
    int left = 0; int right = nums.size() - 1;
    while (left < right) {
        int mid = (left + right) / 2;
        if (nums[mid] >= target) right = mid;
        else left = mid + 1;
    }
    int res = left;
    if (nums[res] != target) return vector<int>{-1, -1};
    left = 0; right = nums.size() - 1;
    while (left < right) {
        int mid = (left + right + 1) / 2;
        if (nums[mid] <= target) left = mid;
        else right = mid - 1;
    }
    return vector<int>{res, left};
}
int main()
{
    vector<int> nums = {5,7,7,8,8,10};
    int target = 0;
    cin >> target;
    vector<int> r = searchRange(nums, target);
    for (auto a : r) {
        cout << a << ' ';
    }
    return 0;
}

4 搜索旋转排序数组

/**
* 整数数组 nums 按升序排列，数组中的值 互不相同 。
 * 在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
 * 给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
 * 你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
*/
#include <iostream>
#include <vector>

using namespace std;
int search(vector<int>& nums, int target) {
    if (nums[0] == target) return 0;
    if (nums.size() == 2 && nums[1] == target) return 1;
    int left = 0; int right = nums.size() - 1;
    int findSection = 0;
    if (nums[0] > target) findSection = 1;
    while (left < right) {
        int mid = (left + right) / 2;
        if (nums[mid] >= nums[0] && findSection == 1) left = mid + 1;
        else if (nums[mid] < nums[0] && findSection == 0) right = mid - 1;
        else {
            if (nums[mid] > target) right = mid - 1;
            else if (nums[mid] < target) left = mid + 1;
            else return mid;
        }
    }
    if (nums[left] == target) return left;
    else return -1;
}
int main()
{
    vector<int> nums = {4,5,6,7,0,1,2};
    int target = 0;
    cin >> target;
    cout << search(nums, target) << endl;
    return 0;
}

5 寻找旋转排序数组中的最小值

/**
* 已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
 * 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
 * 若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
 * 注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
 * 给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
 * 你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
*/
#include <iostream>
#include <vector>

using namespace std;

int findMin(vector<int>& nums) {
    int left = 0; int right = nums.size() - 1;
    while (left < right) {
        int mid = (left + right) / 2;
        if (nums[mid] < nums[right]) right = mid;
        else left = mid + 1;
    }
    return nums[left];
}
int main() {
    vector<int> nums = {4,5,6,7,0,1,2};
    cout << findMin(nums) << endl;
    return 0;
}

6 寻找两个正序数组的中位数

链表
1 相交链表

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0;
        int lenB = 0;
        while (curA != NULL) {
            curA = curA->next;
            lenA++;
        }
        while (curB != NULL) {
            curB = curB->next;
            lenB++;
        }
        curA = headA;
        curB = headB;
        if (lenA < lenB) {
            swap(curA, curB);
            swap(lenA, lenB);
        }
        int gap = lenA - lenB;
        while (gap--) {
            curA = curA->next;
        }
        while (curA != NULL) {
            if (curA == curB) return curA;
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

2 反转链表

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = NULL;
        ListNode* cur = head;
        while (cur != NULL) {
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

3 回文链表

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if (head == NULL) return true;
        vector<int> v;
        ListNode* cur = head;
        while (cur != NULL) {
            v.push_back(cur->val);
            cur = cur->next;
        }
        for (int i = 0, j = v.size() - 1; i < j; i++, j--) {
            if (v[i] != v[j]) return false;
        }
        return true;
    }
};

4 环形链表

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) return true;
        }
        return false;
    }
};

5 环形链表 II

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) {
                ListNode* index1 = head;
                ListNode* index2 = fast;
                while (index1 != index2) {
                index1 = index1->next;
                index2 = index2->next;
            }
            return index1;
            }
        }
        return NULL;
    }
};