leetcode数组汇总_leetcode 数组类型题总结

1，removeDuplicates(I)

1 int removeDuplicatesI(vector& nums){ //重新组织数组，同 removeDuplicates2IV

2 int index = 0;3 for(int i=0;i0 && nums[i] == nums[i-1])5 continue;6 nums[index++] =nums[i];7 }8 returnindex;9 }10 int removeDuplicatesII(vector& nums) { //数组覆盖操作

11 if(nums.empty()) return 0;12 int index = 1;13 for(int i=1;i& nums) { //STL::hashmap

20 mapmapping;21 if(nums.empty()) return 0;22 for(int i=0;i

26 mapping[nums[i]] = 1;27 }28 returnmapping.size();29 }30 int removeDuplicatesIV(vector& nums) { //STL::set

31 setmyset;32 for(int i=0;i& nums) { //STL::unique,STL::distance

37 returndistance(nums.begin(),unique(nums.begin(),nums.end()));38 }

removeDuplicates(I)

removeDuplicates(II)

1 int removeDuplicates2I(vector& nums) { //STL::haspmap

2 mapmapping;3 for(int i=0;isecond == 2)6 mapping.find(nums[i])->second = 2;7 else

8 mapping.find(nums[i])->second += 1;9 }10 else

11 mapping[nums[i]] = 1;12 }13 int result=0;14 for(map::iterator it = mapping.begin();it != mapping.end();++it) {15 result += it->second;16 }17 returnresult;18 }19 int removeDuplicates2II(vector& nums) { //思路同 removeDuplicatesII,覆盖操作，扩展性好

20 if(nums.size()<3) returnnums.size();21 int index = 2; //index表示将要覆盖的三个相同元素的最后一个元素位置

22 for(int i=2;i

25 }26 returnindex;27 }28 int removeDuplicates2III(vector& nums) { //STL::erase 函数

29 if(nums.size()<3) returnnums.size();30 for(vector::iterator it=nums.begin();it!=nums.end()-2;++it)31 if(*it == *(it + 1) && *it == *(it + 2))32 it =nums.erase(it);33 returnnums.size();34 }35 int removeDuplicates2IV(vector& nums) { //重新组织数组

36 int index = 0; //index 表示下次放元素的位置

37 for(int i=0;i1 && i

40 nums[index++] =nums[i];41 }42 returnindex;43 }

removeDuplicates(II)

2, search(I)

1 int search1(const vector& nums,inttarget) {2 int first = 0;3 int last = nums.size()-1;4 while(first <=last) {5 int mid = first + (last - first)/2;6 if(nums[mid]==target)7 returnmid;8 else if(nums[first]<=nums[mid]) { //mid在左半部分

9 if(nums[first]<=target && target

12 first = mid + 1;13 }14 else { //mid在右半部分

15 if(nums[mid]

18 last = mid - 1;19 }20 }21 return -1;22 }

search(I)

search(II)

1 int search2(const vector& nums,inttarget) {2 int first = 0;3 int last = nums.size()-1;4 while(first <=last) {5 int mid = first + (last - first)/2;6 if(nums[mid]==target)7 returnmid;8

9 if(nums[first]<=nums[mid]) { //mid 在左半部分

10 if(nums[first]

11 if(nums[first]<=target && target

14 first = mid + 1;15 }16 else //nums[first] == nums[mid]

17 first++; //缩短查找区间

18 }19 else { //nums[first] > nums[mid]，mid 在右半部分

20 if(nums[mid]

23 last = mid - 1;24 }25 }26 return -1;27 }

search(II)

3，连续序列长度

1 int longestConsecutive(const vector&nums) {2 mapmapping;3 if(nums.empty()) return 0;4 int longestLengths = 1;5 for(int i=0;i

7 }8

9 for(int i=0;i

13 map::iterator it = mapping.find(nums[i]-j);14 if(it !=mapping.end()){15 Lengths++;16 it->second = true;17 }18 else

19 break;20 }21 for(int j=1;;++j) { //从左往右找

22 map::iterator it = mapping.find(nums[i]+j);23 if(it !=mapping.end()) {24 Lengths++;25 it->second = true;26 }27 else

28 break;29 }30 longestLengths =max(longestLengths,Lengths);31 }32 returnlongestLengths;33 }

longestConsecutive

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

1 int findMedianSortedArray(const vector& A,const vector&B) {2 vectorresult;3 result.reserve(A.size()+B.size());4 merge(A.begin(),A.end(),B.begin(),B.end(),result.begin());5 return result[result.size()/2];6

7 }

findMedianSortedArray

5，twoSum

1 vector twoSum1(vector& nums,int target) { //STL::hashmap

2 mapmapping;3 vectorresult;4 for(int i=0;ii){8 result.push_back(i+1);9 result.push_back(target-nums[i]+1);10 break;11 }12 returnresult;13 }14 }15

16 vector twoSum2(vector& nums,int target) { //先排序，再左右夹逼

17 vectorresult;18 int first = 0; //保存元素下标

19 int last = nums.size()-1;20 sort(nums.begin(),nums.end());21 while(firsttarget) {28 last--;29 }30 else{31 first++;32 }33 }34 returnresult;35 }

twoSum

6, threeSum

1 vector > threeSumI(vector& nums) { //跳过重复的数

2 vector >result;3 const int target = 0;4 vector::iterator it;5 for(it=nums.begin();it

6 vector::iterator j=it+1;7 vector::iterator k=nums.end()-1;8 if(it!=nums.begin() && *it == *(it-1)) continue;9 while(j

15 }16 else if(*it + *j + *k

19 }20 else{21 --k;22 while(*k = *(k+1) && j < k) --k; //跳过重复

23 }24 }25 }26 returnresult;27 }28

29 vector> threeSumII(vector& nums) { //不跳过重复的数 ，最后直接去重

30 vector>result;31 const int target = 0;32 vector::iterator it;33 for(it=nums.begin();it::iterator j=it+1;35 vector::iterator k=nums.end()-1;36 if(it!=nums.begin() && *it == *(it-1)) continue;37 while(j ()); //去重

52 result.erase(unique(result.begin(),result.end()),result.end());53 returnresult;54 }55

56 vector> threeSumIII(vector& nums) { //STL::hashmap

57 vector>result;58 map>>cache;59 const int target = 0;60 if(nums.size()<3) returnresult;61 sort(nums.begin(),nums.end());62 for(int i=0;i

71 for(int j=0;j

73 continue;74 vector>& vec =cache[key];75 result.push_back({nums[vec[i].first],nums[vec[i].second],nums[i]});76 }77 }78 sort(result.begin(),result.end()); //可能有重复值,必须去重！比如：nums=[0,0,0,0,0,0],target=0

79 result.erase(unique(result.begin(),result.end()),result.end());80 returnresult;81 }

threeSum

7, threeSumClose

1 int threeSumClose(vector& nums,inttarget) {2 int result = 0;3 int minGap =INT_MAX;4 sort(nums.begin(),nums.end());5 for(int i=0;i

threeSumClose

8, fourSum

1 vector> fourSum(vector& nums,int target) { //先排序，在两边夹逼

2 vector>result;3 if(nums.size()<4) returnresult;4 sort(nums.begin(),nums.end());5 for(int a=0;a

13 ++c;14 --d;15 }16 else if(sum

30

31 vector> fourSum(vector& nums,int target) { //STL::hashmap

32 vector>result;33 if(nums.size()<4) returnresult34 sort(nums.begin(),nums.end());35

36 map>>cache;37 for(int a=0;a

43 for(int c=0;c

48 for(int i=0;i

50 vector>& vec =cache[key];51 result.push_back({nums[vec[i].first],nums[vec[i].second],nums[c],nums[d]});52 }53 }54 }55 sort(result.begin(),result.end());56 result.erase(unique(result.begin(),result.end()),result.end());57 returnresult;58 }59

fourSum

9, removeElement

1 int removeElement1(vector& nums,int target) { //重组

2 int index=0;3 for(int i=0;i

10 int removeElement2(vector& nums,int target) { //覆盖

11 int index=0;12 for(int i=0;i

20 int removeElement3(vector& nums,int target) { //STL::erase

21 vector::iterator it=nums.begin();22 while(it!=nums.end()){23 if(*it==target)24 it =nums.erase(it);25 else

26 ++it;27 }28 returnnums.size();29 }30

31 int removeElement4(vector& nums,int target) { //STL::distance STL::remove(类似于 unique函数)

32 returndistance(nums.begin(),remove(nums.begin(),nums.end(),target));33 }

removeElement

10, trapWater

1 int trapWater1(const vector& heights) { //左右扫描，动态规划思想

2 int result = 0;3 const int n =heights.size();4

5 vector maxLefts(n,0);6 int maxLeftValue = 0;7 for(int i=0;i

8 maxLefts[i] =maxLeftValue;9 maxLeftValue =max(maxLeftValue,heights[i]);10 }11 vector maxRights(n,0); //从右向左扫描，相同的赋值方法 ，保持右边的最大值

12 int maxRightValue = 0;13 for(int j=n-1;j>=0;--j) {14 maxRights[j] =maxRightValue;15 maxRightValue =max(maxRightValue,heights[j]);16 }17 for(int k=0;kheights[k]) {20 result += diff -heights[k];21 }22 }23 returnresult;24 }25

26 int trapWater2(const vector& heights) { //左右夹逼思想

27 int result=0;28 int l=0,r=heights.size()-1;29 while(l heights[l] && l heights[r] && l

45 int trapWater3(const vector& heights) { //对每个可能存水的柱子进行讨论，动态规划用的数组类似缓存的作用

46 int result = 0;47 const int n = heights.size()-1;48 int maxLeft = 0;49 int maxRight = 0;50 for(int i=1;i

51 for(int j=0;j

52 maxLeft = max(heights[j-1],heights[j]);53 }54 for(int k=i+1;k

55 maxRight = max(heights[k],heights[k+1]);56 }57 int diff =min(maxLeft,maxRight);58 if(diff >heights[i])59 result += diff -heights[i];60 }61 returnresult;62 }

trapWater

11,  climbStairs

1 int climbStairs1(int n) { //迭代

2 int prev = 0;3 int curr = 1;4 for(int i=1;i<=n;++i) {5 int temp =curr;6 curr = prev +curr;7 prev =temp;8 }9 returncurr;10 }11

12 int climbStairs2(int n) { //递归(效率低)

13 if(n==1 || n==2) returnn;14 return climbStairs2(n-1) + climbStairs2(n-2);15 }16

17 int climbStairs3(int n) { //数学公式法

18 const double s = sqrt(5);19 return floor((pow((1+s)/2,n+1) + pow((1-s)/2,n+1))/s + 0.5); //数学公式

20 }

climbStairs

12, grayCode

1 vector grayCode1(int n){ //数学公式方式

2 int size = 1 << n; //2^n

3 vectorresult;4 result.reserve(size);5 for (int i = 0; i < size; ++i)6 result.push_back(i ^ (i >> 1));7 returnresult;8 }9

10 vector grayCode2(int n) { //暂时未看懂

11 vectorresult;12 result.reserve(1 <= 0; --j) {17 result.push_back(highest_bit |result[j]);18 }19 }20 returnresult;21 }

grayCode

13, candy

1 int candy(vector&ratings){2 const int n =ratings.size();3 vector nums(n, 1);4 for (int i = 0; i < n-1; ++i){5 if (ratings[i] < ratings[i+1])6 nums[i+1] = nums[i] + 1;7 }8 for (int j = n - 1; j>0; --j){9 if (ratings[j] < ratings[j - 1])10 nums[j - 1] = max(nums[j - 1], nums[j] + 1);11 }12 return accumulate(nums.begin(), nums.end(),0);13 }14

15 int candyII(vector& ratings) { //思路同 上面 trapWater 的两次扫描

16 if (ratings.size() == 0) return 0;17 vector minLeft(ratings.size(), 1);18 for (unsigned int i = 1; iratings[i - 1])20 minLeft[i] = minLeft[i - 1] + 1;21 }22 vector minRight(ratings.size(), 1);23 for (unsigned int j = ratings.size() - 2; j >= 0; --j){24 if (ratings[j]>ratings[j + 1]) //如果左边的等级高，而且左边的糖果又少的话

25 minRight[j] = max(minLeft[j], (minRight[j + 1] + 1));26 }27 int result = 0;28 for (unsigned int k = 0; k

30 returnresult;31 }

candy

14，singleNumber(I)

1 #include //bit_xor()

2

3 int singleNumber1(vector&nums){4 int x = 0;5 for (unsigned int i = 0; i < nums.size(); ++i)6 x ^=nums[i];7 returnx;8 }9

10 int singleNumber2(vector&nums) {11 return accumulate(nums.begin(), nums.end(), 0, bit_xor());12 }

singleNumber

singleNumber(II)

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

7 }8 result += (sum % 3) << i; //result |= (sum % 3) << i;

9 }10 returnresult;11 }

singleNumber(II)1

int singleNumberII2(vector&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] <

}returnresult;

}

singleNumber(II)2