高效面试之数组专题中级篇（leetcode）

目录
1、编号2 Median of Two Sorted Arrays
2、编号15 Long Common Prefix 
3、编号25 Remove Element (双指针)
4、编号26 Remove Duplicates from Sorted Array (双指针)
5、编号32 Search for a Range (折半查找)
6、编号33 Search in Rotated Sorted Array
7、编号35 Search Insert Position (折半查找)
8、编号40 First Missing Positive (桶)
9、编号51 Anagrams (Map)
10、编号67 Plus One
11、编号68 Text Justification
12、编号 Sort Colors (三指针)
13、编号80 Remove Duplicates from Sorted Array II (双指针)
14、编号81 Search in Rotated Sorted Array II
15、编号89 Merge Sorted Array
16、编号 Longest Consecutive Sequence  (哈希表)
17、编号137 Single Number  (位运算)
18、编号138 Single Number II (位运算)

1、编号2 Median of Two Sorted Arrays
There are two sorted arrays A and B of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
由于要求时间复杂度是O(log (m+n))，所有带log的时间复杂度一般都要折半查找，这个就是这样。因为有两个数组，一个四个部分，那么每次就把这四个部分丢掉一个。所有要求每个数组的中间元素。代码比较长。注意长度为2或者1的特殊情况。更多信息点这里

[cpp]  view plain copy

1. public:  
2.     double findMedianSortedArrays(int A[], int m, int B[], int n) {  
3.         return FindMedian(A, 0, m, B, 0, n);  
4.     }  
5.       
6.     double GetMedian(int X[], int start, int end){  
7.         int l = end - start;  
8.         if(l == 0) return 0;  
9.         if(l == 1) return X[start];  
10.         if(l%2 == 0){  
11.             return (X[start+l/2-1] + X[start+l/2])/2.0f;  
12.         }else{  
13.             return X[start+l/2];  
14.         }  
15.     }  
16.       
17.     double GetMedian(int X[], int start, int end, int extrax){  
18.         int l = end - start;  
19.         int Y[l+1];  
20.         int j = 0;  
21.         bool flag = true;  
22.         for(int i = 0; i < l; i++) {  
23.             if(extrax < X[start + i] && flag){  
24.                 Y[j++] = extrax;  
25.                 flag = false;  
26.             }  
27.             Y[j++] = X[start+i];  
28.         }  
29.           
30.         if(flag) Y[j++] = extrax;  
31.   
32.   
33.         return GetMedian(Y, 0, l+1);  
34.     }  
35.       
36.     double GetMedian(int X[], int start, int end, int extrax, int extray){  
37.         int l = end - start;  
38.         int Y[l+2];  
39.         int j = 0;  
40.         bool flagX = true;  
41.         bool flagY = true;  
42.         for(int i = 0; i < l; i++) {  
43.             if(extrax < X[start + i] && flagX){  
44.                 Y[j++] = extrax;  
45.                 flagX = false;  
46.             }      
47.             if(extray < X[start + i] && flagY){  
48.                 Y[j++] = extray;  
49.                 flagY = false;  
50.             }   
51.             Y[j++] = X[start+i];  
52.         }  
53.           
54.         if(flagX) Y[j++] = extrax;  
55.         if(flagY) Y[j++] = extray;  
56.           
57.         return  GetMedian(Y, 0, l+2);  
58.     }  
59.       
60.     int Min(int m, int n){  
61.     return m>n?n:m;  
62.     }  
63.       
64.     double SortMedian(int x1, int x2, int y1, int y2){  
65.         int mid_max = x2;  
66.         int mid_min = x1;  
67.           
68.         if(y2 < x2) mid_max = y2;  
69.         if(y1 > x1) mid_min = y1;  
70.          
71.         return (mid_min+mid_max)/2.0f;   
72.     }  
73.       
74.     double FindMedian(int A[], int m_start, int m_end, int B[], int n_start, int n_end) {  
75.         double mA = GetMedian(A, m_start, m_end);  
76.         double mB = GetMedian(B, n_start, n_end);  
77.   
78.   
79.         int m = m_end - m_start;  
80.         int n = n_end - n_start;  
81.         int min_mn = Min(m,n);  
82.         int r= min_mn/2-1;  
83.         if(r == 0) r = 1;  
84.           
85.         if(m == 0) return mB;  
86.         if(n == 0) return mA;  
87.         if(m==1 && n==1) return (mA+mB)/2.0f;  
88.         if(m==2 && n==2) return SortMedian(A[m_start], A[m_start+1],B[n_start], B[n_start+1]);  
89.           
90.         if(m==1) return GetMedian(B, n_start, n_end, A[m_start]);  
91.         if(n==1) return GetMedian(A, m_start, m_end, B[n_start]);  
92.         if(m==2) return GetMedian(B, n_start, n_end, A[m_start], A[m_start+1]);  
93.         if(n==2) return GetMedian(A, m_start, m_end, B[n_start], B[n_start+1]);  
94.   
95.   
96.         if(mA == mB){  
97.             return mA;  
98.         }else if(mA > mB){  
99.             return FindMedian(A, m_start, m_end-r, B, n_start+r, n_end);  
100.         }else{  
101.             return FindMedian(A, m_start+r , m_end, B, n_start, n_end-r);  
102.         }           
103.     }  

2、编号15 Long Common Prefix 

Write a function to find the longest common prefix string amongst an array of strings. 
求很多数组的最长公共前缀。方法是把第一个数组作为参考数组，以下每一个数组都跟参考数组比较。要是它们的共同数组比参考数组的短，那么就更新共同数组的长度；否则就继续比较下一个数组。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     string longestCommonPrefix(vector<string> &strs) {  
4.         if(strs.size() == 0) return "";  
5.         string finalResult;  
6.         int finalResultCount = strs[0].size();/*Use strs[0] as reference*/  
7.   
8.   
9.         for(int i = 1; i < strs.size(); i++){  
10.             int tmpCount = 0;  
11.             for(int j = 0; j < strs[i].size(); j++){  
12.                 if(strs[0].size() >= j){  
13.                     if(strs[0][j] == strs[i][j]) tmpCount++;  
14.                     else break;  
15.                 }else tmpCount++;  
16.             }  
17.             if(tmpCount < finalResultCount) finalResultCount = tmpCount;  
18.         }  
19.         /*Generate result*/  
20.         for(int i = 0; i < finalResultCount; i++) finalResult += strs[0][i];  
21.         return finalResult;  
22.     }  
23. };  

3、编号25 Remove Element 
Given an array and a value, remove all instances of that value in place and return the new length. The order of elements can be changed. It doesn't matter what you leave beyond the new length. 

比较简单的题。方法是双指针。建立一个insertIndex指针跟i一起遍历。当i遇到要删除的字符时，i走而insertIndex不走。到下一步把i的值盖在insertIndex的地方。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     int removeElement(int A[], int n, int elem) {  
4.         int insertIndex = 0;  
5.         int length = n;  
6.         for(int i = 0; i < n; i++){  
7.             A[insertIndex] = A[i];  
8.             if(A[i] == elem)length--;  
9.             else insertIndex++;  
10.         }  
11.         return length;  
12.     }  
13. };  

4、编号26 Remove Duplicates from Sorted Array Given a sorted array, remove the duplicates in place such that each element appear only once and return the new length.
Do not allocate extra space for another array, you must do this in place with constant memory.

For example, Given input array A = [1,1,2],

Your function should return length = 2, and A is now [1,2].

跟上一题差不多的简单题。因为没有比较的数字了，所以用上面一个数字来比较。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     int removeDuplicates(int A[], int n) {  
4.         int insertIndex = 1;  
5.         int length = n;  
6.         int lastElem = A[0];  
7.         for(int i = 1; i < n; i++){  
8.             A[insertIndex] = A[i];  
9.             if(A[i] == lastElem)length--;  
10.             else insertIndex++;  
11.             lastElem = A[i];  
12.         }  
13.         return length;   
14.     }  
15. };  

5、编号32 Search for a Range

Given a sorted array of integers, find the starting and ending position of a given target value.
Your algorithm's runtime complexity must be in the order of O(log n).
If the target is not found in the array, return [-1, -1].
For example, Given [5, 7, 7, 8, 8, 10] and target value 8, return [3, 4].

时间复杂度为 O(log n)，则用折半查找。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     vector<int> searchRange(int A[], int n, int target) {  
4.         vector<int> result;  
5.         result.push_back(Recursive(A, target, 0, n, false));  
6.         result.push_back(Recursive(A, target, 0, n, true));  
7.         return result;  
8.     }  
9.       
10.     int Recursive(int A[], int target, int start, int end, bool findMax){  
11.         if((end-start)==1 || (end-start)==0){  
12.             if(A[start] == target) return start;  
13.             else return -1;  
14.         }  
15.         int m = (end-start)/2;  
16.               
17.         if(A[start+m] == target){  
18.             if(!findMax){/*For find min*/  
19.                 if(A[start+m-1] == target)  
20.                     return Recursive(A, target, start, start+m, findMax);  
21.                 else return start+m;  
22.             }else{/*For find max*/  
23.                 if(A[start+m+1] == target)  
24.                     return Recursive(A, target, start+m, end, findMax);  
25.                 else return start+m;  
26.             }  
27.         }  
28.           
29.         /*Goes here if the mid point element is not equal to the target*/  
30.         if(A[start+m] < target)  
31.             return Recursive(A, target, start+m, end, findMax);  
32.         else  
33.             return Recursive(A, target, start, start+m, findMax);  
34.     }  
35. };  

6、编号33 Search in Rotated Sorted Array

Suppose a sorted array is rotated at some pivot unknown to you beforehand.
(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
You are given a target value to search. If found in the array return its index, otherwise return -1.
You may assume no duplicate exists in the array.

题目貌似是要考一个特殊的折半查找。但是没有规定时间效率，所以用O(n)的简单方法就可以过。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     int search(int A[], int n, int target) {  
4.         for(int i = 0; i < n; i++){  
5.             if(A[i] == target) return i;  
6.         }  
7.         return -1;  
8.     }  
9. };  

7、编号35 Search Insert Position

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
You may assume no duplicates in the array.
Here are few examples.
[1,3,5,6], 5 → 2
[1,3,5,6], 2 → 1
[1,3,5,6], 7 → 4
[1,3,5,6], 0 → 0

比较简单，用折半查找来做。注意边界条件就可以了。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     int searchInsert(int A[], int n, int target) {  
4.        return Recursive(A, 0, n, target);   
5.     }  
6.       
7.     int Recursive(int A[], int start, int end, int target){  
8.         int l = end - start;  
9.         if(l==1 || l==0){  
10.             if(A[start] >= target) return start;  
11.             if(A[start] < target) return start+1; /*Becareful here*/  
12.         }  
13.           
14.         int m = l / 2;  
15.         if(A[start + m] == target) return start + m;   
16.         if(A[start + m] > target)  
17.             return Recursive(A, start, start+m, target); /*Remeber dont use +-1 here*/  
18.         else  
19.             return Recursive(A, start+m, end, target);  
20.     }  
21. };  

8、编号40 First Missing Positive

Given an unsorted integer array, find the first missing positive integer.
For example,
Given [1,2,0] return 3,
and [3,4,-1,1] return 2.
Your algorithm should run in O(n) time and uses constant space.

比较经典的一类题。因为这题有两个限制，一个是运行时间必须线性，而是不能使用额外的数组空间。但是也提供了有力条件，就是找到最先确实的正整数。所以把原数组当作木桶。如果没有元素缺失的话，每个木桶i都刚好能装大小为i+1的那个数。那么只要尝试把所有的数字装进对应的桶里面，然后再次从前往后遍历整个桶，看哪个桶装的不是正确的数字，那个桶所代表的数字就是缺失的数字。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.      int firstMissingPositive(int A[], int n) {  
4.          int i = 0;  
5.          while (i < n){  
6.              if (A[i] != (i+1) && A[i] >= 1 && A[i] <= n && A[A[i]-1] != A[i])  
7.                  swap(A[i], A[A[i]-1]);  
8.              else  
9.                  i++;  
10.          }  
11.          for (i = 0; i < n; ++i)  
12.              if (A[i] != (i+1))  return i+1;  
13.          return n+1;  
14.     }  
15. };  

9、编号51 Anagrams

Given an array of strings, return all groups of strings that are anagrams.
Note: All inputs will be in lower-case.

Anagrams题的特点是只考虑字母，不考虑顺序。那么要比较两个字符串是否相等的话，可以先排序，然后Anagrams的字符都会变成一样的字符串。从前往后遍历字符串数组，如果发现没找到过的排序后字符串，则记录。当两次发现同样的排序字符串之后，把它们对应的原字符串加入结果中。如果再次找到一个相同的就只用输入新的那个字符串。所以使用影射map来做，排序后的字符串对应字符串的次序。如果该字符串已经输出过了，则标记为-1。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     vector<string> anagrams(vector<string> &strs) {    
4.         map<string,int> m;    
5.         vector<string> result;    
6.         for(int i = 0; i < strs.size(); i++) {    
7.             string a = strs[i];    
8.             sort(a.begin(), a.end());    
9.             if(m.find(a) == m.end()) m[a] = i;    
10.             else{    
11.                 int index = m[a];    
12.                 if(index >= 0)  {    
13.                     result.push_back(strs[index]);    
14.                     m[a] = -1;    
15.                 }    
16.                 result.push_back(strs[i]);    
17.             }    
18.         }    
19.         return result;    
20.     }    
21. };  

10、编号67 Plus One

Given a number represented as an array of digits, plus one to the number.

链表类也有一个类似的加一的题。处理好进位就可以了。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     vector<int> plusOne(vector<int> &digits) {  
4.         bool carry = false;  
5.         for(int i = digits.size()-1; i >= 0; i--){  
6.             int x;  
7.             if(i == digits.size()-1) x = digits[i] + 1; /*!!!!*/  
8.             else x = digits[i];  
9.               
10.             if(carry) x++;  
11.               
12.             if(x >= 10) {  
13.                 digits[i] = x - 10;  
14.                 carry = true;  
15.             }else {  
16.                 digits[i] = x;  
17.                 carry = false;  
18.             }  
19.         }  
20.           
21.         if(carry) digits.insert(digits.begin(), 1);  
22.           
23.         return digits;  
24.     }  
25. };  

11、编号68 Text Justification

Given an array of words and a length L, format the text such that each line has exactly L characters and is fully (left and right) justified.
You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces ' ' when necessary so that each line has exactly L characters.
Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.
For the last line of text, it should be left justified and no extra space is inserted between words.
For example,
words: ["This", "is", "an", "example", "of", "text", "justification."]
L: 16.
Return the formatted lines as:
[
   "This    is    an",
   "example  of text",
   "justification.  "
]
Note: Each word is guaranteed not to exceed L in length.

用贪心算法，在每行放入尽可能多的词组。每次放入一个词组时，有三种情况：1、该行刚好放满。假入这不是最后一个词的话，下一个词就要重起一行。2、该行长度超了。那么要退出这一个单词，新起一行，再把单词放进去。3、该行长度小于最大长度。这个最简单，只要加入这个单词就可以了。另外要注意的是加入单词后要如题目所述调整间距，所以写了SettingSpace()这个函数。应该可以减小代码长度的，但是这题有点恶心。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     vector<string> fullJustify(vector<string> &words, int L) {  
4.         vector<string> r;  
5.   
6.         string tmp = "";  
7.         r.push_back(tmp);  
8.         int lineCount = 0;  
9.         int stringInLineCount = 0;  
10.         int wordsInLineCount = 0;  
11.           
12.         if(L == 0) return r;  
13.         /*Even words = [""], it is still words.size() = 1*/  
14.         if(words[0] == ""){  
15.             r[0] = SettingSpace(r[0], 0, 0, L, false);  
16.             return r;  
17.         }  
18.           
19.         for(int i = 0; i < words.size(); i++){  
20.             stringInLineCount += words[i].length();  
21.             if(stringInLineCount == L){  
22.                 /*Add word*/  
23.                 r[lineCount] += words[i];  
24.                 wordsInLineCount++;  
25.                 /*SettingSpace*/  
26.                 r[lineCount] = SettingSpace(r[lineCount], stringInLineCount, wordsInLineCount, L, false);  
27.                 /*Start a new line if this word is not the last word*/  
28.                 if(i != words.size()-1){  
29.                     string tmp = "";  
30.                     r.push_back(tmp);  
31.                     stringInLineCount = 0;  
32.                     wordsInLineCount = 0;  
33.                     lineCount++;  
34.                 }  
35.             }else if(stringInLineCount > L){  
36.                 /*Remove words*/  
37.                 stringInLineCount -= words[i].length();  
38.                 /*SettingSpace*/  
39.                 r[lineCount] = SettingSpace(r[lineCount], stringInLineCount, wordsInLineCount, L, false);  
40.                 /*Start a new line and Add word*/  
41.                 string tmp = words[i];  
42.                 r.push_back(tmp);  
43.                 stringInLineCount = words[i].length();  
44.                 wordsInLineCount = 1;  
45.                 lineCount++;  
46.                 /*After adding word, add a space, if there is word next*/  
47.                 if((i != words.size()-1) && (stringInLineCount < L)){  
48.                     stringInLineCount++;  
49.                     r[lineCount] += ' ';  
50.                 }  
51.             }else{  
52.                 /*Add word*/  
53.                 r[lineCount] += words[i];  
54.                 wordsInLineCount++;  
55.                 /*After adding word, add a space, if there is word next*/  
56.                 if((i != words.size()-1) && (stringInLineCount < L)){  
57.                     stringInLineCount++;  
58.                     r[lineCount] += ' ';  
59.                 }  
60.             }  
61.         }  
62.           
63.         /*Need setting space for the last line*/  
64.         r[lineCount] = SettingSpace(r[lineCount], stringInLineCount, wordsInLineCount, L, true);  
65.           
66.         return r;  
67.     }  
68.       
69.     string SettingSpace(string x, int stringInLineCount, int wordsInLineCount, int L, bool lastLine){  
70.         int spaceCount = 0;  
71.         int n = x.length();  
72.         //if(x[n-1] == ' ') n--;  
73.         for(int i = 0; i < n; i++)   
74.             if(x[i] == ' ') spaceCount++;  
75.         spaceCount += (L - stringInLineCount);  
76.           
77.         if(wordsInLineCount < 2 || lastLine){  
78.             for(int i = stringInLineCount; i < L; i++ ){  
79.                 x += ' ';  
80.             }  
81.             return x;  
82.         }else{  
83.             int spaceBetween = spaceCount / (wordsInLineCount-1);  
84.             int extraSpace = spaceCount % (wordsInLineCount-1);  
85.             string tmp;  
86.             int count = 0;  
87.             int spaceNum = 0;  
88.             for(int i = 0; i < L; i++) {  
89.                 if(spaceNum > 0){  
90.                     tmp += ' ';  
91.                     spaceNum--;  
92.                     continue;  
93.                 }  
94.                 if(x[count] != ' '){  
95.                     tmp += x[count];  
96.                     count++;  
97.                 }else{  
98.                     tmp += ' ';  
99.                     spaceNum = spaceBetween-1;  
100.                     if(extraSpace > 0) {spaceNum++; extraSpace--;}  
101.                     count++;  
102.                 }  
103.             }  
104.             return tmp;  
105.         }  
106.     }  
107. };  

12、编号 Sort Colors

Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.
Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
Note: You are not suppose to use the library's sort function for this problem.
Follow up:
A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's, then 1's and followed by 2's.
Could you come up with an one-pass algorithm using only constant space?

一个特殊的排序问题。只扫描一遍，不用辅助数组，把所有0移到前面，并把所有2移到最后。使用三指针法。目标是，第一个指针指向0的终点，第二个指针指向2，最后一个指针用来遍历。中间的位置是1。遍历开始，当三号指针找到0的时候，把0和一号指针的位置交换，然后一号指针往后走一步。当三号指针找到2的时候，把2和二号指针的位置交换，然后二号指针往前走一步。指导二号和三号指针相遇，颜色就排好了。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     void sortColors(int A[], int n) {  
4.         int zeroIndex = 0;  
5.         int twoIndex = n-1;  
6.         int i = 0;/*One Index*/  
7.           
8.         while(i < (twoIndex+1)){  
9.             if(A[i] == 0){  
10.                 Swap(A[i], A[zeroIndex]);  
11.                 zeroIndex++;  
12.                 i++;  
13.                 continue;  
14.             }  
15.   
16.             if(A[i] == 2){  
17.                 Swap(A[i], A[twoIndex]);  
18.                 twoIndex--;  
19.                 continue;  
20.             }  
21.             i++;  
22.         }  
23.     }  
24.       
25.     void Swap(int &x, int &y){  
26.         int tmp = x;  
27.         x = y;  
28.         y = tmp;  
29.     }  
30. };  

13、编号80 Remove Duplicates from Sorted Array II

Follow up for "Remove Duplicates":
What if duplicates are allowed at most twice?
For example, Given sorted array A = [1,1,1,2,2,3],
Your function should return length = 5, and A is now [1,1,2,2,3].

编号26的升级版，允许出现两个的复制。思路会有些不同。对于每一个元素，必须同时比较它的上一个和再上一个元素，如果它们都相等，才能删掉其中一个元素。定义一个offset变量，在每个step开始的时候，根据这个变量覆盖原数组。用这个方法，允许出现三个复制的也可以做。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     int removeDuplicates(int A[], int n) {  
4.         if(n <= 2) return n;  
5.           
6.         int lastElem = A[0];  
7.         int offset = 0;  
8.           
9.         for(int i = 2; i < n;){  
10.             A[i] = A[i+offset];  
11.             if(A[i] == lastElem && A[i-1] == lastElem) {  
12.                 offset++;  
13.                 n--;  
14.             }else i++;  
15.             lastElem = A[i-2];  
16.         }  
17.           
18.         return n;  
19.     }  
20. };  

14、编号81 Search in Rotated Sorted Array II

Follow up for "Search in Rotated Sorted Array":
What if duplicates are allowed?
Would this affect the run-time complexity? How and why?
Write a function to determine if a given target is in the array.

编号33的变种。允许两个复制存在。返回的是数据是否存在的bool变量。但是简单的方法仍然可以通过大数据...

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     bool search(int A[], int n, int target) {  
4.         for(int i = 0; i < n; i++){  
5.             if(A[i] == target) return true;  
6.         }  
7.         return false;        
8.     }  
9. };  

15、编号89 Merge Sorted Array

Given two sorted integer arrays A and B, merge B into A as one sorted array.
Note:
You may assume that A has enough space to hold additional elements from B. The number of elements initialized in A and B are m and n respectively.

把B数组merge到A数组里面。由于A会被覆盖，所以建立一个辅助数组v，先把merge后的数据放进v，然后再把A同步到v一样就可以了。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     void merge(int A[], int m, int B[], int n) {  
4.         int i = 0;  
5.         int j = 0;  
6.         vector<int> v;  
7.         for(int count = 0; count < m+n; count++){  
8.             if(i == m)  
9.                 v.push_back(B[j++]);  
10.             else if(j == n)  
11.                 v.push_back(A[i++]);  
12.             else{  
13.                 if(A[i]<B[j]) v.push_back(A[i++]);  
14.                 else v.push_back(B[j++]);  
15.             }  
16.         }  
17.           
18.         for(int i = 0; i< v.size(); i++) A[i] = v[i];  
19.     }  
20. };  

16、编号 Longest Consecutive Sequence

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.
For example, Given [100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
Your algorithm should run in O(n) complexity.

要求了运行时间必须是线性，但没有限制空间。则用哈希表来实现。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     int longestConsecutive(vector<int> &num) {  
4.         int result = 0;  
5.           
6.         unordered_map<int, int> hashMap;  
7.           
8.         for(int i = 0; i < num.size(); i++) hashMap[num[i]] = 1;  
9.           
10.         for(int i = 0; i < num.size(); i++){  
11.             if(hashMap[num[i]] == 1){  
12.                 hashMap[num[i]] = 0;  
13.                 int len = 1;  
14.                 int left = num[i]-1;  
15.                 int right = num[i]+1;  
16.                 while(hashMap.count(left) && hashMap[left]){  
17.                     hashMap[left--] = 0;  
18.                     len++;  
19.                 }  
20.                 while(hashMap.count(right) && hashMap[right]){  
21.                     hashMap[right++] = 0;  
22.                     len++;  
23.                 }  
24.                 if(len > result) result = len;  
25.             }  
26.         }  
27.         return result;  
28.     }  
29. };  

17、编号137 Single Number

Given an array of integers, every element appears twice except for one. Find that single one.
Note: Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

找到之出现一次的那个点。无论是排序也好，哈希表也好，都很容易做。但是要同时限制时间和空间，一般方法就不行了。搜了一下，只能用位运算来做。用一个整型result来记录，result^=A[i], 出现两次的话，两次亦或消失为0，只出现一次的被result记录下来，最后返回0^result。

^异或运算 XOR
    1   ^   1   ==   0
    1   ^   0   ==   1
    0   ^   1   ==   1
    0   ^   0   ==   0

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     int singleNumber(int A[], int n) {  
4.         int result = 0;  
5.         for(int i = 0; i < n; i++) result ^= A[i];  
6.         return result;  
7.     }  
8. };  

18、编号138 Single Number II

Given an array of integers, every element appears three times except for one. Find that single one.
Note: Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

上一题的升级版，更加困难了。方法也还是只能用位运算，如下。

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.     int singleNumber(int A[], int n) {  
4.         int one = 0, two = 0, three = 0;  
5.         for (int i = 0; i < n; ++i) {  
6.             two |= one & A[i]; //出现两次的 就加到B里面  
7.             one ^= A[i]; //从A里面删除 出现两次的  
8.             three = one & two;  //如果是三次的 就会同时出现在A和B里面，   
9.             one &= ~three; //然后删除A里三次的  
10.             two &= ~three;  //删除B里三次的  
11.         }  
12.         return one;  
13.     }  
14. };