【LeetCode数据结构刷题】数组（2）

第二天打卡 【数组】

1. 两数之和

题目描述：
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

class Solution
{
public:
    //枚举
    vector<int> twoSum(vector<int>& nums, int target)
    {
        int i, j;
        for(i=0; i<nums.size(); i++)
        {
            for(j=i+1; j<nums.size(); j++)
            {
                if(nums[i] + nums[j] == target)
                    return {i, j};
            }
        }
        return {};
    }

    //哈希表
    vector<int> twoSum_HashMap(vector<int>& nums, int target) {
        unordered_map<int, int> hashtable;
        for (int i = 0; i < nums.size(); ++i) {
            auto it = hashtable.find(target - nums[i]);
            if (it != hashtable.end()) {
            	//return {hashtable[target - nums[i]], i};
                return {it->second, i};
            }
            hashtable[nums[i]] = i;
        }
        return {};
    }
};


int main()
{
    vector<int> arr = {2,5,5,11};
    Solution solution;
    vector<int> result = solution.twoSum(arr, 10);
    cout << "enumeration: [" << result[0] << ',' << result[1] << ']' << endl;
    vector<int> result1 = solution.twoSum_HashMap(arr, 10);
    cout << "hash map: [" << result1[0] << ',' << result1[1] << ']' << endl;
    return 0;
}

复盘

1、哈希表

c++中，unordered_map可以当作哈希表来使用。哈希查找的时间复杂度为 O(1)O(1)，所以可以利用哈希容器 map 降低时间复杂度。
it->first会得到key，
it->second会得到value。

88. 合并两个有序数组

题目描述：
给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
说明:
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:
输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
输出: [1,2,2,3,5,6]

#include <iostream>
#include <vector>

using namespace std;

class Solution
{
public:
    vector<int> merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        for (int i = 0; i != n; ++i) {
            nums1[m + i] = nums2[i];
        }
        QuickSort(nums1, 0, nums1.size()-1);
        return nums1;
    }

    void QuickSort(vector<int>& num, int low, int high){
        if(low < high){
            int pivotpos = Partition(num, low, high);
            QuickSort(num, low, pivotpos-1);
            QuickSort(num, pivotpos+1, high);
        }
    }

    int Partition(vector<int>& num, int low, int high){
        int pivot = num[low];
        while(low < high){
            while(low < high && num[high] >= pivot){
                --high;
            };
            num[low] = num[high];
            while(low < high && num[low] <= pivot){
                ++low;
            }
            num[high] = num[low];
        }
        num[low] = pivot;
        return low;
    }
};


int main()
{
    vector<int> arr1 = {1,2,3,0,0,0};
    vector<int> arr2 = {2,5,6};
    Solution solution;
    vector<int> result = solution.merge(arr1,3, arr2,3);
    for(int i=0; i<result.size(); ++i)
        cout << result[i] << ' ';
    return 0;
}

#include <iostream>
#include <vector>

using namespace std;

class Solution
{
public:
	//逆向指针
    vector<int> merge(vector<int>& nums1, int m, vector<int>& nums2, int n)
    {
        int i = m-1;
        int j = n-1;
        for(int k=m+n-1; k>=0; k--){
          if (j < 0 || (i >= 0 && nums1[i] >= nums2[j])) {
                nums1[k] = nums1[i];
                i--;
            } else {
                nums1[k] = nums2[j];
                j--;
            }
        }
        return nums1;
    }
};

int main()
{
    vector<int> arr1 = {1,2,3,0,0,0};
    vector<int> arr2 = {2,5,6};
    Solution solution;
    vector<int> result = solution.merge(arr1,3, arr2,3);
    for(int i=0; i<result.size(); ++i)
        cout << result[i] << ' ';
    return 0;
}

复盘

1、双指针

题目中说明num1和num2已经被排序的性质。为了利用这一性质，我们可以使用双指针方法。双指针发要避免覆盖 nums1 中的元素被覆盖，要使用临时变量

2、逆向指针

由题知，nums1的后半部分是空的，可以直接覆盖而不会影响结果。因此可以指针设置为从后向前遍历，每次取两者之中的较大者放进nums1的最后面。