Leetcode Top100题目和答案(1-10)

Leetcode Top100题目和答案(1-10)

1. 两数之和 (Two Sum)

问题描述：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
解决思路：使用哈希表来存储数组中的值及其索引，以便在一次遍历中找到目标值。
代码示例（C++14）：

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

2. 反转链表 (Reverse Linked List)

问题描述：反转一个单链表。
解决思路：使用迭代或递归的方法反转链表。
代码示例（C++14）：

   ListNode* reverseList(ListNode* head) {
       ListNode* prev = nullptr;
       ListNode* curr = head;
       while (curr != nullptr) {
           ListNode* nextTemp = curr->next;
           curr->next = prev;
           prev = curr;
           curr = nextTemp;
       }
       return prev;
   }
   

3. 合并两个有序链表 (Merge Two Sorted Lists)

问题描述：将两个升序链表合并为一个新的升序链表。
解决思路：使用双指针遍历两个链表，逐一比较节点值并合并。
代码示例（C++14）：

   ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
       ListNode dummy(0);
       ListNode* tail = &dummy;
       while (l1 && l2) {
           if (l1->val < l2->val) {
               tail->next = l1;
               l1 = l1->next;
           } else {
               tail->next = l2;
               l2 = l2->next;
           }
           tail = tail->next;
       }
       tail->next = l1 ? l1 : l2;
       return dummy.next;
   }
   

4. 最长回文子串 (Longest Palindromic Substring)

问题描述：给定一个字符串，找到最长的回文子串。
解决思路：使用动态规划或中心扩展法。
代码示例（C++14）：

   string longestPalindrome(string s) {
       if (s.empty()) return "";
       int n = s.size(), start = 0, maxLen = 1;
       vector<vector<bool>> dp(n, vector<bool>(n, false));
       for (int i = 0; i < n; ++i) dp[i][i] = true;
       for (int i = n - 1; i >= 0; --i) {
           for (int j = i + 1; j < n; ++j) {
               if (s[i] == s[j]) {
                   if (j - i == 1 || dp[i + 1][j - 1]) {
                       dp[i][j] = true;
                       if (j - i + 1 > maxLen) {
                           start = i;
                           maxLen = j - i + 1;
                       }
                   }
               }
           }
       }
       return s.substr(start, maxLen);
   }
   

5. 有效的括号 (Valid Parentheses)

问题描述：给定一个只包括 (, ), {, }, [ 和 ] 的字符串，判断字符串是否有效。
解决思路：使用栈来匹配括号。
代码示例（C++14）：

   bool isValid(string s) {
       stack<char> stack;
       for (char c : s) {
           if (c == '(' || c == '{' || c == '[') {
               stack.push(c);
           } else {
               if (stack.empty()) return false;
               char top = stack.top();
               stack.pop();
               if ((c == ')' && top != '(') || (c == '}' && top != '{') || (c == ']' && top != '[')) {
                   return false;
               }
           }
       }
       return stack.empty();
   }
   

6. 删除排序数组中的重复项 (Remove Duplicates from Sorted Array)

问题描述：给定一个排序数组，删除重复项，使每个元素只出现一次，并返回新的长度。
解决思路：使用双指针法。
代码示例（C++14）：

   int removeDuplicates(vector<int>& nums) {
       if (nums.empty()) return 0;
       int i = 0;
       for (int j = 1; j < nums.size(); j++) {
           if (nums[j] != nums[i]) {
               i++;
               nums[i] = nums[j];
           }
       }
       return i + 1;
   }
   

7. 买卖股票的最佳时机 (Best Time to Buy and Sell Stock)

问题描述：给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。
解决思路：一次遍历，记录最小价格和最大利润。
代码示例（C++14）：

   int maxProfit(vector<int>& prices) {
       int minPrice = INT_MAX;
       int maxProfit = 0;
       for (int price : prices) {
           if (price < minPrice) {
               minPrice = price;
           } else if (price - minPrice > maxProfit) {
               maxProfit = price - minPrice;
           }
       }
       return maxProfit;
   }
   

8. 旋转数组 (Rotate Array)

问题描述：给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
解决思路：使用反转法。
代码示例（C++14）：

   void rotate(vector<int>& nums, int k) {
       k = k % nums.size();
       reverse(nums.begin(), nums.end());
       reverse(nums.begin(), nums.begin() + k);
       reverse(nums.begin() + k, nums.end());
   }
   

9. 打家劫舍 (House Robber)

问题描述：你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统。
解决思路：使用动态规划。
代码示例（C++14）：

   int rob(vector<int>& nums) {
       if (nums.empty()) return 0;
       if (nums.size() == 1) return nums[0];
       vector<int> dp(nums.size(), 0);
       dp[0] = nums[0];
       dp[1] = max(nums[0], nums[1]);
       for (int i = 2; i < nums.size(); i++) {
           dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
       }
       return dp.back();
   }
   

10. 二叉树的最大深度 (Maximum Depth of Binary Tree)

问题描述：给定一个二叉树，找出其最大深度。
解决思路：使用递归。
代码示例（C++14）：

    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }