数组中的两数之和

问题描述：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

#include <vector>  
#include <unordered_map>  
  
std::vector<int> twoSum(std::vector<int>& nums, int target) {  
    std::unordered_map<int, int> numMap;  
    for (int i = 0; i < nums.size(); ++i) {  
        int complement = target - nums[i];  
        if (numMap.count(complement)) {  
            return {numMap[complement], i};  
        }  
        numMap[nums[i]] = i;  
    }  
    return {}; // 如果没有找到，返回空数组  
}  

旋转数组搜索

问题描述：假设一个按照升序排列的数组在预先未知的某个点上进行了旋转（例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2]）。请你在其中搜索一个目标值，如果数组中包含这个目标值，则返回它的索引，否则返回 -1。

int search(std::vector<int>& nums, int target) {  
    int left = 0, right = nums.size() - 1;  
    while (left <= right) {  
        int mid = left + (right - left) / 2;  
        if (nums[mid] == target) {  
            return mid;  
        }  
        if (nums[left] <= nums[mid]) { // 左半部分有序  
            if (target >= nums[left] && target < nums[mid]) {  
                right = mid - 1;  
            } else {  
                left = mid + 1;  
            }  
        } else { // 右半部分有序  
            if (target > nums[mid] && target <= nums[right]) {  
                left = mid + 1;  
            } else {  
                right = mid - 1;  
            }  
        }  
    }  
    return -1; // 没有找到目标值  
}  

数组中第k大的元素

问题描述：在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

#include <vector>  
#include <queue>  
  
int findKthLargest(std::vector<int>& nums, int k) {  
    std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap; // 小顶堆  
    for (int num : nums) {  
        minHeap.push(num);  
        if (minHeap.size() > k) {  
            minHeap.pop(); // 保持堆的大小为k  
        }  
    }  
    return minHeap.top(); // 第k大的元素在小顶堆的顶部  
}  

数组中的最长连续序列

问题描述：给定一个未排序的整数数组，找出最长连续序列的长度。要求算法的时间复杂度为 O(n)。

#include <vector>  
#include <unordered_set>  
  
int longestConsecutive(std::vector<int>& nums) {  
    std::unordered_set<int> numSet(nums.begin(), nums.end()); // 将数组转换为集合，以便快速查找  
    int longestStreak = 0;  
  
    for (int num : numSet) {  
        // 只对序列中的最小数进行处理，避免重复计算连续序列  
        if (numSet.find(num - 1) == numSet.end()) {  
            int currentNum = num;  
            int currentStreak = 1;  
  
            while (numSet.find(currentNum + 1) != numSet.end()) {  
                currentNum += 1;  
                currentStreak += 1;  
            }  
  
            longestStreak = std::max(longestStreak, currentStreak);  
        }  
    }  
  
    return lo