题目链接：移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

方法：哈希表

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size(),l = 0,r = 0;
        while (r < n) {
            if (nums[r]) {
                swap(nums[l],nums[r]);
                l++;
            }
            r++;
        }
    }
};

题目链接：最长连续序列

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

方法：哈希表

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_set<int> nums_set;
        for (int num : nums) {
            nums_set.insert(num);
        }
        int ans = 0;
        for (int num : nums_set) {
            if (!nums_set.count(num-1)) {
                int cur = num;
                int curs = 1;
                while (nums_set.count(cur+1)) {
                    cur += 1;
                    curs += 1;
                }
                ans = max(ans,curs);
            }
        }
        return ans;
    }
};

题目链接：字母异位词分组

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

方法：排序

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        vector<vector<string>> ans;
        unordered_map<string,vector<string>> mp;
        for (string& str : strs) {
            string key = str;
            sort(key.begin(),key.end());
            mp[key].emplace_back(str);
        }
        for (auto it = mp.begin();it != mp.end();it++) {
            ans.emplace_back(it->second);
        }
        return ans;
    }
};

题目链接：两数之和

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

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

方法一：暴力枚举

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

方法二：哈希表

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> hashtable;
        for (int i = 0;i < nums.size();i++) {
            auto t = hashtable.find(target-nums[i]);
            if (t != hashtable.end()) {
                return {t->second,i};
            }
            hashtable[nums[i]] = i;
        }
        return {};
    }
};

如果您看到这篇文章,表示您的 blog 已经安装成功.