leetcode 数组类型题总结

1，removeDuplicates（I）

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

removeDuplicates（II）

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

removeDuplicates(II)

2, search(I)

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

search(I)

search(II)

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

search(II)

3，连续序列长度

 int longestConsecutive(const vector<int>& nums) {
     map<int,bool> mapping;
     if(nums.empty()) return ;
     int longestLengths = ;
     for(int i=;i<nums.size();++i) {
         mapping[nums[i]] = false;      // 用来表示该元素是否用过，因为同一连续序列的元素的连续序列长度相同，无序再计算
     }

     for(int i=;i<nums.size();++i) {
         int Lengths = ;
         if(mapping[nums[i]]) continue;
         for(int j = ;;++j) {       // 从右边往左边找
             map<int,bool>::iterator it = mapping.find(nums[i]-j);
             if(it != mapping.end()){
                 Lengths++;
                 it->second = true;
             }
             else
                 break;
         }
         for(int j=;;++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;
 }

longestConsecutive

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()/];

 }

findMedianSortedArray

5，twoSum

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

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

twoSum

6, threeSum

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

 vector<vector<int>> threeSumII(vector<int>& nums) {  //不跳过重复的数 ，最后直接去重
     vector<vector<int>> result;
     const int target = ;
     vector<int>::iterator it;
     for(it=nums.begin();it<nums.end()-;++it) {
         vector<int>::iterator j=it+;
         vector<int>::iterator k=nums.end()-;
         if(it!=nums.begin() && *it == *(it-)) 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 = ;
     if(nums.size()<) return result;
     sort(nums.begin(),nums.end());
     for(int i=;i<nums.size();++i){
         for(int j=i+;j<nums.size();++j) {
             cache[nums[i]+nums[j]].push_back(make_pair(i,j));
         }
     }
     for(int i=;i<nums.size();++i) {
         const int key = target - nums[i];
         if(cache.find(key)==cache.end()) continue;

         for(int j=;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;
 }

threeSum

7, threeSumClose

 int threeSumClose(vector<int>& nums,int target) {
     int result = ;
     int minGap = INT_MAX;
     sort(nums.begin(),nums.end());
     for(int i=;i<nums.size()-;++i) {
         int j=i+;
         int k=nums.size()-;
         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;
 } 

threeSumClose

8, fourSum

 vector<vector<int>> fourSum(vector<int>& nums,int target) { //先排序，在两边夹逼
     vector<vector<int>> result;
     if(nums.size()<) return result;
     sort(nums.begin(),nums.end());
     for(int a=;a<nums.size()-;++a) {
         for(int b=a+;b<nums.size()-;++b) {
             int c=b+;
             int d=nums.size()-;
             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()<) return result
     sort(nums.begin(),nums.end());

     map<int,vector<pair<int,int>>> cache;
     for(int a=;a<nums.size();++a) {
         for(int b=a+;b<nums.size();++b) {
             cache[nums[a]+nums[b]].push_back(make_pair(a,b))
         }
     }

     for(int c=;c<nums.size();++c) {
         for(int d=c+;d<nums.size();++c) {
             int key = target - nums[c] - nums[d];
             if(cache.find(key)==cache.end()) continue;

             for(int i=;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;
 }
  

fourSum

9, removeElement

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

 int removeElement2(vector<int>& nums,int target) { // 覆盖
     int index=;
     for(int i=;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));
 }

removeElement

10, trapWater

 int trapWater1(const vector<int>& heights) {  // 左右扫描，动态规划思想
     int result = ;
     const int n = heights.size();

     vector<int> maxLefts(n,);
     int maxLeftValue = ;
     for(int i=;i<n;++i) {  // 从左向右扫描,注意这种赋值方法 ,保持左边的最大值
         maxLefts[i] = maxLeftValue;
         maxLeftValue =  max(maxLeftValue,heights[i]);
     }
     vector<int> maxRights(n,);  // 从右向左扫描，相同的赋值方法 ，保持右边的最大值
     int maxRightValue = ;
     for(int j=n-;j>=;--j) {
         maxRights[j] = maxRightValue;
         maxRightValue = max(maxRightValue,heights[j]);
     }
     for(int k=;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=;
     int l=,r=heights.size()-;
     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 = ;
     const int n = heights.size()-;
     int maxLeft = ;
     int maxRight = ;
     for(int i=;i<n-;++i) {  // 每一个可能存雨的柱子
         for(int j=;j<i;++j) {  // 找左边最大的柱子
             maxLeft = max(heights[j-],heights[j]);
         }
         for(int k=i+;k<n-;++k) {  // 找右边最大的柱子
             maxRight = max(heights[k],heights[k+]);
         }
         int diff = min(maxLeft,maxRight);
         if(diff > heights[i])
             result += diff - heights[i];
     }
     return result;
 } 

trapWater

11,  climbStairs

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

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

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

climbStairs

12, grayCode

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

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

grayCode

13, candy

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

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

candy

14，singleNumber（I）

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

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

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

singleNumber

　　singleNumber(II)

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

singleNumber(II)1

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

singleNumber(II)2

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