leetcode 数组类型题总结

1，removeDuplicates（I）

int removeDuplicatesI(vector<int>& nums){  // 重新组织数组，同 removeDuplicates2IV
    int index = 0;
    for(int i=0;i<nums.size();++i){
        if(i>0 && nums[i] == nums[i-1])
            continue; 
        nums[index++] = nums[i];
    }
    return index;
} 
int removeDuplicatesII(vector<int>& nums) { // 数组覆盖操作 
    if(nums.empty()) return 0;
    int index = 1;
    for(int i=1;i<nums.size();++i) {
        if(nums[i-1] != nums[i])
            nums[index++] = nums[i];
    }
    return index;
}
int removeDuplicatesIII(vector<int>& nums) {  //  STL::hashmap 
    map<int,int> mapping;
    if(nums.empty()) return 0;
    for(int i=0;i<nums.size();++i) {
        if(mapping.find(nums[i]) != mapping.end())
            mapping[nums[i]] += 1;
        else
            mapping[nums[i]] = 1;
    }
    return mapping.size();
}
int removeDuplicatesIV(vector<int>& nums) {   // STL::set
    set<int> myset;
    for(int i=0;i<nums.size();++i)
        myset.insert(nums[i]);
    return myset.size();
}
int removeDuplicatesV(vector<int>& nums) {    // STL::unique,STL::distance
    return distance(nums.begin(),unique(nums.begin(),nums.end()));
}

 removeDuplicates（II）

int removeDuplicates2I(vector<int>& nums) {  //  STL::haspmap 
    map<int,int> mapping;
    for(int i=0;i<nums.size();++i) {
        if(mapping.find(nums[i]) != mapping.end()){
            if(mapping.find(nums[i])->second == 2)
                mapping.find(nums[i])->second = 2;
            else
                mapping.find(nums[i])->second += 1;
        }
        else
            mapping[nums[i]] = 1;
    }
    int result=0;
    for(map<int,int>::iterator it = mapping.begin();it != mapping.end();++it) {
        result += it->second;
    }
    return result;
}
int removeDuplicates2II(vector<int>& nums) { // 思路同  removeDuplicatesII,覆盖操作，扩展性好 
    if(nums.size()<3) return nums.size();
    int index = 2; // index表示将要覆盖的三个相同元素的最后一个元素位置 
    for(int i=2;i<nums.size();++i) {
        if(nums[i] != nums[index-2])
            nums[index++] = nums[i]; // 覆盖三个相同元素的最后一个 
    }
    return index;
}
int removeDuplicates2III(vector<int>& nums) {  // STL::erase 函数 
    if(nums.size()<3) return nums.size();
    for(vector<int>::iterator it=nums.begin();it!=nums.end()-2;++it)
        if(*it == *(it + 1) && *it == *(it + 2))
            it = nums.erase(it);
    return nums.size();
} 
int removeDuplicates2IV(vector<int>& nums) {  // 重新组织数组 
    int index = 0;  // index 表示下次放元素的位置 
    for(int i=0;i<nums.size();++i){
        if(i>1 && i<nums.size()-1 && nums[i]==nums[i-1] && nums[i]==nums[i+1])
            continue; // 和左右两边相等的元素跳过（不放入重组数组中） 
        nums[index++] = nums[i];
    } 
    return index;
}

2, search(I)

int search1(const vector<int>& nums,int target) {
    int first = 0;
    int last = nums.size()-1;
    while(first <= last) {
        int mid = first + (last - first)/2;
        if(nums[mid]==target) 
            return mid;
        else if(nums[first]<=nums[mid]) { // mid在左半部分 
            if(nums[first]<=target && target<nums[mid])
                last = mid - 1;
            else
                first = mid + 1; 
        }    
        else {                         // mid在右半部分 
            if(nums[mid]<target && target<=nums[last])
                first = mid + 1;
            else
                last = mid - 1; 
        }
    }
    return -1;
}

    search(II)

int search2(const vector<int>& nums,int target) {
    int first = 0;
    int last = nums.size()-1;
    while(first <= last) {
        int mid = first + (last - first)/2;
        if(nums[mid]==target)
            return mid;
            
        if(nums[first]<=nums[mid]) {      // mid 在左半部分 
            if(nums[first]<nums[mid]) {   // nums[first] < nums[mid]
                if(nums[first]<=target && target<nums[mid])
                    last = mid - 1;
                else
                    first = mid + 1;
            }
            else                        // nums[first] == nums[mid]
                first++;                // 缩短查找区间 
        }
        else {                         //  nums[first] > nums[mid]，mid 在右半部分 
            if(nums[mid]<target && target<=nums[last])
                first = mid +1;
            else
                last = mid - 1;
        }
    }
    return -1;
}

 3，连续序列长度

int longestConsecutive(const vector<int>& nums) {
    map<int,bool> mapping;
    if(nums.empty()) return 0;
    int longestLengths = 1;
    for(int i=0;i<nums.size();++i) {
        mapping[nums[i]] = false;      // 用来表示该元素是否用过，因为同一连续序列的元素的连续序列长度相同，无序再计算 
    }
    
    for(int i=0;i<nums.size();++i) {
        int Lengths = 1; 
        if(mapping[nums[i]]) continue;
        for(int j = 1;;++j) {       // 从右边往左边找 
            map<int,bool>::iterator it = mapping.find(nums[i]-j);
            if(it != mapping.end()){
                Lengths++;
                it->second = true;  
            }    
            else
                break;        
        }
        for(int j=1;;++j) {   // 从左往右找 
            map<int,bool>::iterator it = mapping.find(nums[i]+j);
            if(it != mapping.end()) {
                Lengths++;
                it->second = true;
            }        
            else
                break;
        }
        longestLengths = max(longestLengths,Lengths);
    }
    return longestLengths;
}

 4, 查询两个有序数组的第 K 个元素

int findMedianSortedArray(const vector<int>& A,const vector<int>& B) {
    vector<int> result;
    result.reserve(A.size()+B.size());
    merge(A.begin(),A.end(),B.begin(),B.end(),result.begin());
    return result[result.size()/2];
    
}

5，twoSum

vector<int> twoSum1(vector<int>& nums,int target) {  // STL::hashmap
    map<int,int> mapping;
    vector<int> result;
    for(int i=0;i<nums.size();++i)
        mapping[nums[i]] = i;
    for(int i=0;i<nums.size();++i){
        if(mapping.find(target-nums[i])!=mapping.end() && mapping[target-nums[i]]>i){
            result.push_back(i+1);
            result.push_back(target-nums[i]+1);
            break;
        }
        return result;
    }
} 

vector<int> twoSum2(vector<int>& nums,int target) {  // 先排序，再左右夹逼 
    vector<int> result; 
    int first = 0;  // 保存元素下标 
    int last = nums.size()-1;
    sort(nums.begin(),nums.end());
    while(first<last) {
        if(nums[first] + nums[last] == target){
            result.push_back(first+1);
            result.push_back(last+1);
            break;
        }
        if(nums[first] + nums[last] > target) {
            last--;
        }
        else {
            first++;
        }
    }
    return result;
}

6, threeSum

vector<vector<int> > threeSumI(vector<int>& nums) {  //跳过重复的数 
    vector<vector<int> > result;
    const int target = 0;
    vector<int>::iterator it;
    for(it=nums.begin();it<nums.end()-2;++it) { // 遍历第一个数，剩余两个数进行夹逼 
        vector<int>::iterator j=it+1;
        vector<int>::iterator k=nums.end()-1;
        if(it!=nums.begin() && *it == *(it-1)) continue;
        while(j < k) {
            if(*it + *j + *k == target){
                result.push_back({*it,*j,*k});
                ++j;
                --k;
                while(*j == *(j-1) && *k = *(k+1) && j < k) ++j; // 跳过重复的数 
            }
            else if(*it + *j + *k < target){
                ++j;
                while(*j == *(j-1) && j < k) ++j;  // 跳过重复 
            } 
            else {
                --k;
                while(*k = *(k+1) && j < k) --k;   // 跳过重复 
            }
        }
    }
    return result;
}

vector<vector<int>> threeSumII(vector<int>& nums) {  //不跳过重复的数 ，最后直接去重 
    vector<vector<int>> result;
    const int target = 0;
    vector<int>::iterator it;
    for(it=nums.begin();it<nums.end()-2;++it) { 
        vector<int>::iterator j=it+1;
        vector<int>::iterator k=nums.end()-1;
        if(it!=nums.begin() && *it == *(it-1)) continue;
        while(j < k) {
            if(*it + *j + *k == target){
                result.push_back({*it,*j,*k});
                ++j;
                --k;
            }
            else if(*it + *j + *k < target){
                ++j; 
            } 
            else {
                --k; 
            }
        }
    }
    sort(result.begin(),result.end(),less<int>());    // 去重 
    result.erase(unique(result.begin(),result.end()),result.end()); 
    return result;
}

vector<vector<int>> threeSumIII(vector<int>& nums) { // STL::hashmap
    vector<vector<int>> result;
    map<int,vector<pair<int,int>>> cache;
    const int target = 0;
    if(nums.size()<3) return result;
    sort(nums.begin(),nums.end());
    for(int i=0;i<nums.size();++i){
        for(int j=i+1;j<nums.size();++j) {
            cache[nums[i]+nums[j]].push_back(make_pair(i,j));
        }
    } 
    for(int i=0;i<nums.size();++i) {
        const int key = target - nums[i];
        if(cache.find(key)==cache.end()) continue;
        
        for(int j=0;j<cache[key].size();++j) {
            if(i<=cache[key].second)    //不会出现  [1,2,3],[1,3,2] [2,1,3]都被加入的情况，如果这行不写，最后需要对每个新加入的 vector 排序，然后加入，最后判重。 
                continue;
            vector<pair<int,int>>& vec = cache[key];
            result.push_back({nums[vec[i].first],nums[vec[i].second],nums[i]});
        }
    }
    sort(result.begin(),result.end());   // 可能有重复值,必须去重！比如：nums=[0,0,0,0,0,0],target=0 
    result.erase(unique(result.begin(),result.end()),result.end());
    return result;
}

7, threeSumClose

int threeSumClose(vector<int>& nums,int target) {
    int result = 0;
    int minGap = INT_MAX;
    sort(nums.begin(),nums.end());
    for(int i=0;i<nums.size()-2;++i) {
        int j=i+1;
        int k=nums.size()-1;
        while(j<k) {
            int sum = nums[i]+nums[j]+nums[k];
            int gap = abs(target-sum);
            if(gap<minGap) {
                result = sum;
                minGap = gap;
            }
            if(sum<target) ++j;
            else           --k;
        } 
    }
    return result;
} 

8, fourSum

vector<vector<int>> fourSum(vector<int>& nums,int target) { //先排序，在两边夹逼 
    vector<vector<int>> result;
    if(nums.size()<4) return result;
    sort(nums.begin(),nums.end());
    for(int a=0;a<nums.size()-3;++a) {
        for(int b=a+1;b<nums.size()-2;++b) {
            int c=b+1;
            int d=nums.size()-1;
            while(c < d) {
                int sum = nums[a]+nums[b]+nums[c]+nums[d];
                if(sum==target) {
                    result.push_back({nums[a],nums[b],nums[c],nums[d]});  // 每次加入的 vector 都是升序的，hashmap 则不一定，需要判断！！！ 
                    ++c;
                    --d;
                }
                else if(sum < target) {
                    ++c;
                }
                else {
                    --d;
                }
            }
        }
    }
    sort(result.begin(),result.end());
    result.erase(unique(rusult.begin(),result.end()),result.end());
    return result;
}


vector<vector<int>> fourSum(vector<int>& nums,int target) {  // STL::hashmap
    vector<vector<int>> result;
    if(nums.size()<4) return result
    sort(nums.begin(),nums.end());
    
    map<int,vector<pair<int,int>>> cache;
    for(int a=0;a<nums.size();++a) {
        for(int b=a+1;b<nums.size();++b) {
            cache[nums[a]+nums[b]].push_back(make_pair(a,b))
        }
    }
    
    for(int c=0;c<nums.size();++c) {
        for(int d=c+1;d<nums.size();++c) {
            int key = target - nums[c] - nums[d];
            if(cache.find(key)==cache.end()) continue;
            
            for(int i=0;i<cache[key].size();++i) {
                if(c<=cache[key].second) continue; // 有重叠
                vector<pair<int,int>>& vec = cache[key];
                result.push_back({nums[vec[i].first],nums[vec[i].second],nums[c],nums[d]});
            }
        }
    }
    sort(result.begin(),result.end());
    result.erase(unique(result.begin(),result.end()),result.end());
    return result; 
}
 

 9, removeElement

int removeElement1(vector<int>& nums,int target) { // 重组 
    int index=0;
    for(int i=0;i<nums.size();++i) {
        if(nums[i]!=target)
            nums[index++]=nums[i];
    }
    return index;
}

int removeElement2(vector<int>& nums,int target) { // 覆盖 
    int index=0;
    for(int i=0;i<nums.size();++i) {
        if(nums[i]==target)
            continue;
        nums[index++]=nums[i];
    }
    return index;
} 

int removeElement3(vector<int>& nums,int target) {  // STL::erase
    vector<int>::iterator it=nums.begin();
    while(it!=nums.end()){
            if(*it==target)
                it = nums.erase(it);
            else
                ++it;
    }
    return nums.size();        
} 

int removeElement4(vector<int>& nums,int target) {  // STL::distance  STL::remove(类似于 unique函数)
    return distance(nums.begin(),remove(nums.begin(),nums.end(),target));
}

 10, trapWater

int trapWater1(const vector<int>& heights) {  // 左右扫描，动态规划思想 
    int result = 0;
    const int n = heights.size();
    
    vector<int> maxLefts(n,0);
    int maxLeftValue = 0;
    for(int i=0;i<n;++i) {  // 从左向右扫描,注意这种赋值方法 ,保持左边的最大值 
        maxLefts[i] = maxLeftValue;
        maxLeftValue =  max(maxLeftValue,heights[i]);
    }
    vector<int> maxRights(n,0);  // 从右向左扫描，相同的赋值方法 ，保持右边的最大值 
    int maxRightValue = 0;
    for(int j=n-1;j>=0;--j) {
        maxRights[j] = maxRightValue;
        maxRightValue = max(maxRightValue,heights[j]);
    } 
    for(int k=0;k<n;++k) {
        int diff = min(maxLefts[k],maxRights[k]);
        if(diff>heights[k]) {
            result += diff - heights[k];
        }
    } 
    return result;
}

int trapWater2(const vector<int>& heights) {  // 左右夹逼思想 
    int result=0;
    int l=0,r=heights.size()-1;
    while(l < r) {
        int mn = min(heights[l],heights[r]);
        if(mn == heights[l]) {
            ++l;
            while(mn>heights[l] && l < r)
                result += mn - heights[l++];
        }
        else {
            --r;
            while(mn > heights[r] && l < r) 
                result += mn - heights[r--];
        }
    }
    return result;
}

int trapWater3(const vector<int>& heights) {  // 对每个可能存水的柱子进行讨论，动态规划用的数组类似缓存的作用 
    int result = 0;
    const int n = heights.size()-1;
    int maxLeft = 0;
    int maxRight = 0; 
    for(int i=1;i<n-1;++i) {  // 每一个可能存雨的柱子 
        for(int j=0;j<i;++j) {  // 找左边最大的柱子 
            maxLeft = max(heights[j-1],heights[j]);
        } 
        for(int k=i+1;k<n-1;++k) {  // 找右边最大的柱子 
            maxRight = max(heights[k],heights[k+1]);
        }
        int diff = min(maxLeft,maxRight);
        if(diff > heights[i])
            result += diff - heights[i];
    }
    return result;
} 

 11,  climbStairs

int climbStairs1(int n) {  // 迭代 
    int prev = 0;
    int curr = 1;
    for(int i=1;i<=n;++i) {
        int temp = curr;
        curr = prev + curr;
        prev = temp;
    }
    return curr;
}

int climbStairs2(int n) {  // 递归（效率低） 
    if(n==1 || n==2) return n;
    return climbStairs2(n-1) + climbStairs2(n-2);  
} 

int climbStairs3(int n) {  // 数学公式法 
    const double s = sqrt(5);
    return floor((pow((1+s)/2,n+1) + pow((1-s)/2,n+1))/s + 0.5); // 数学公式 
}

 12, grayCode

vector<int> grayCode1(int n){  // 数学公式方式
    int size = 1 << n; //2^n
    vector<int> result;
    result.reserve(size);
    for (int i = 0; i < size; ++i)
        result.push_back(i ^ (i >> 1));
    return result;
}

vector<int> grayCode2(int n) {  // 暂时未看懂
    vector<int> result;
    result.reserve(1 << n);
    result.push_back(0);
    for (int i = 0; i < n; ++i) {
        const int highest_bit = 1 << i;
        for (int j = result.size() - 1; j >= 0; --j) {
            result.push_back(highest_bit | result[j]);
        }
    }
    return result;
}

 13, candy

int candy(vector<int>& ratings){
    const int n = ratings.size();
    vector<int> nums(n, 1);
    for (int i = 0; i < n-1; ++i){
        if (ratings[i] < ratings[i+1])
            nums[i+1] = nums[i] + 1;
    }
    for (int j = n - 1; j>0; --j){
        if (ratings[j] < ratings[j - 1])
            nums[j - 1] = max(nums[j - 1], nums[j] + 1);
    }
    return accumulate(nums.begin(), nums.end(),0);
}

int candyII(vector<int>& ratings) {  //思路同 上面 trapWater 的两次扫描
    if (ratings.size() == 0) return 0;
    vector<int> minLeft(ratings.size(), 1);
    for (unsigned int i = 1; i<ratings.size(); ++i){
        if (ratings[i]>ratings[i - 1])
            minLeft[i] = minLeft[i - 1] + 1;
    }
    vector<int> minRight(ratings.size(), 1);
    for (unsigned int j = ratings.size() - 2; j >= 0; --j){
        if (ratings[j]>ratings[j + 1]) //如果左边的等级高，而且左边的糖果又少的话 
            minRight[j] = max(minLeft[j], (minRight[j + 1] + 1));
    }
    int result = 0;
    for (unsigned int k = 0; k<ratings.size(); ++k)
        result += max(minLeft[k], minRight[k]);  //取从左边和右边都最小的值中的最大值，这样就满足所有条件了。 
    return result;
}

 14，singleNumber（I）

#include<functional> //bit_xor<int>()

int singleNumber1(vector<int>& nums){
    int x = 0;
    for (unsigned int i = 0; i < nums.size(); ++i)
        x ^= nums[i];
    return x;
}

int singleNumber2(vector<int>& nums) {
    return accumulate(nums.begin(), nums.end(), 0, bit_xor<int>());
}

 　　singleNumber(II)

int singleNumberII(vector<int>& nums) {
    int result = 0;
    for (int i = 0; i < 32; ++i){
        int sum = 0;
        for (unsigned int j = 0; j < nums.size(); ++j){
            sum += (nums[j] >> i) & 1; // 求所有数的某一位是 1 的个数
        }
        result += (sum % 3) << i;    // result |= (sum % 3) << i;
    }
    return result;
}

int singleNumberII2(vector<int>& nums) {
    const int W = sizeof(int)* 8;  // 一个整数的位数
    int count[W];  // count[i] 表示在第 i 位出现 1 的个数
    for (size_t i = 0; i < nums.size(); ++i) {
        for (int j = 0; j < W; ++j) {
            count[j] += (nums[i] >> j) & 1;
            count[j] %= 3;
        }
    }
    int result = 0;
    for (int i = 0; i < W; ++i) {  // 最后把唯一出现的数字计算出来
        result += (count[i] << i);
    }
    return result;
}

博客中的题目来源于：https://github.com/soulmachine/leetcode  (leetcode-cpp.pdf)