数据结构之数组mark

leetcode 合并两个有序数组

• 主要思想：遍历一次进行比较，从后往前进行复制填充

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) 
    {
        int cur = nums1.size() - 1;
        while(m && n)
        {
            if(nums1[m-1] >= nums2[n-1])
            {
               nums1[cur--] = nums1[m-1];
                m--;
            }
            else
            {
                nums1[cur--] = nums2[n-1];
                n--;
            }
        }
        
        while(n)
        {
            nums1[cur--] = nums2[n-1];
            n--;
        } 
    }
};

两数之和

• 主要思想：一般涉及寻找下表这种，均可以采用哈希表，将值和下表保存起来，查询方便

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        vector<int> ret;
        unordered_map<int,int> mymap;  
        int len = nums.size();
        int i, j;
        for(i = 0; i < len; i++)
        {
            mymap[nums[i]] = i;
        }
        
        for(j = 0; j < len; j++)
        {
            int tmp = target - nums[j];
            if(mymap.find(tmp) != mymap.end() && mymap[tmp] > j )
            {
                ret.push_back(j);
                ret.push_back(mymap[tmp]);
                break;
            }
        }
        return ret;
    }
};

快乐数

• 主要思想：采用哈希表，将值和下表保存起来，查询方便，不是快乐数就会发生循环重复

class Solution {
    bool subHappy(int n, unordered_map<int,int>& mymap)
    {
        int sum = 0;
        while(n)
        {
            sum += pow(n%10, 2);
            n /= 10;
        }
        if(mymap.find(sum) != mymap.end())
            return false;
        if(sum == 1)
            return true;
        else
        {
            
            mymap[sum] = sum;
            return subHappy(sum, mymap);
        }
    }
public:
    bool isHappy(int n) {
        unordered_map<int,int> mymap;
        return subHappy(n, mymap);
    }
};

三数之和

• 主要思想：排序 去重和双指针夹逼定理

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int size = nums.size();
        vector<vector<int>> res;
        if(size < 3) return res;
        //先排序
        sort(nums.begin(), nums.end());
        int repetNum = nums[0];
        for(int i = 0; i < size - 2; i++)
        {
            //去除最外层循环重复元素
            if(i > 0)
            {
                if(nums[i] == repetNum)
                    continue;
                else
                    repetNum = nums[i];
            }
            
            //双指针夹逼
            int left = i + 1;
            int right = size - 1;
            if(nums[i] > 0 || nums[right] < 0)
                continue;
            
            while(left < right)
            {
                if(nums[left] + nums[right] > -nums[i])
                    right--;
                else if(nums[left] + nums[right] < -nums[i])
                    left++;
                else
                {
                    vector<int> tmp;
                    tmp.push_back(nums[i]);
                    tmp.push_back(nums[left]);
                    tmp.push_back(nums[right]);
                    res.push_back(tmp);
                    left++;
                    right--;
                    while(nums[left] == nums[left - 1] && left < right)
                        left++;
                    while(nums[right] == nums[right + 1] && left < right)
                        right--; 
                }
            }
        }
        return res;
    }
};

求众数

• 主要思想：众数即超过一半的数字

class Solution {
public:
    int majorityElement(vector<int>& nums) 
    {
        int cnt = 1;
        int majority = nums[0];
        for(int i = 1; i < nums.size(); i++)
        {
            if(cnt == 0)
                majority = nums[i];

            if(majority == nums[i])
                cnt++;
            else
                cnt--;
        }
        return majority;
    }
};

缺失的第一个正数

• 主要思路：遍历一次数组把大于等于1的和小于数组大小的值放到一个新数组中，是的值和下标相同，然后再遍历一次数组查当前下标是否和值对应，如果不对应那这个下标就是答案，否则遍历完都没出现那么答案就是数组长度加1

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        int size = nums.size();
        if(size == 0)
            return 1;
        int arr[size + 1] = {0};
        for(int i = 0; i < size; i++)
        {
            if(nums[i] >= 1 && nums[i] <= size)
                //主要是这一行
                arr[nums[i]] = 1;
        }
        for(int i = 1; i <= size; i++)
        {
            if(arr[i] == 0)
                return i;
        }
        return arr[1] == 1 ? size + 1 : 1;
    }
};