使用了並查集的思路。建立一個鍵值為節點值，值為是否出現過以及對應節點索引的二元組。遍歷整個陣列的過程中，判斷是否有相鄰的數出現，如果未出現相鄰的數，則將其新增至雜湊表中，如果出現了一個相鄰的數，則新增至雜湊表，並將father陣列對應的值改為這個相鄰數的“根節點值”，這個節點值通過getfather函式獲得，如果兩端都有相鄰的，則將較小的數對應的根節點值賦給他，然後將較大的相鄰的值的根結點同樣改為前面較小的書對應的根節點。空間佔用好像有點大，貼程式碼

 1 class Solution {
 2 public:
 3     int getfather(vector<int>& father,int
 
 index)
 4     {
 5         while(father[index]!=index)
 6         index = father[index];
 7         return index;
 8     }
 9     int longestConsecutive(vector<int>& nums) 
10     {
11         int n = nums.size();
12         //並查集
13         vector<int> father(n);
14         for(int i = 0
 
 ; i < n ; i++)
15         father[i] = i;
16         //兩個雜湊表
17         unordered_map<int,pair<bool,int>> numsHash;
18         unordered_map<int,int> sizeHash;
19         //最大值
20         int maxSize = 0;
21         for(int i = 0 ; i < n ; i++)
22         {
23             //只有該陣列在雜湊中未出現才會考慮
 

24             if(!numsHash[nums[i]].first)
25             {
26                 if(numsHash[nums[i]-1].first && numsHash[nums[i]+1].first)
27                 {
28                     //cout<<i<<endl;
29                     //向前靠
30                     numsHash[nums[i]] = {true,i};
31                     int index = getfather(father,numsHash[nums[i]-1].second);
32                     father[i] = index;  
33                     //將後一個的合併
34                     int indexLatter = getfather(father,numsHash[nums[i]+1].second);
35                     //cout<<indexLatter<<endl;
36                     father[indexLatter] = index;
37                 }
38                 else if(numsHash[nums[i]-1].first)
39                 {
40                     int index = getfather(father,numsHash[nums[i]-1].second);
41                     father[i] = index;
42                     numsHash[nums[i]] = {true,i};  
43                 }
44                 else if(numsHash[nums[i]+1].first)
45                 {
46                     int index = getfather(father,numsHash[nums[i]+1].second);
47                     father[i] = index; 
48                     numsHash[nums[i]] = {true,i}; 
49                 }
50                 else 
51                 {
52                     //完成在雜湊表中賦值
53                     numsHash[nums[i]] = {true,i};
54                 }
55             }
56         }
57         //完成並查集建立，開始計算結果
58         for(int i = 0 ; i < n ; i++)
59         {
60             //cout<<getfather(father,i)<<endl;
61             int currentSize = ++sizeHash[getfather(father,i)];
62             //cout<<currentSize<<endl;
63             if(currentSize>maxSize)
64             maxSize = currentSize;
65         }
66         return maxSize;
67     }
68 };

還有一種很好的方法，首先通過雜湊表儲存所有的陣列元素，這樣也能起到去重的作用。之後就對每個陣列元素做一件事，在雜湊表中查詢+1的元素是否存在，重複上述過程直到找不到為止。有一個小細節就是，在查詢之前先判斷當前節點值-1的數是否存在，如果存在，就代表從自己開始的序列的結果不可能優於自己-1為頭的序列。這樣就可以很大程度上減少重複查詢，貼程式碼

 1 class Solution {
 2 public:
 3     int longestConsecutive(vector<int>& nums) 
 4     {
 5         unordered_set<int> numsHash;
 6         for(auto temp:nums)
 7         numsHash.insert(temp);
 8         int maxSize = 0;
 9         for(const int& num:numsHash)
10         {
11             if(!numsHash.count(num-1))
12             {
13                 int currentNum = num;
14                 int currentLen = 1;
15                 while(numsHash.count(currentNum+1))
16                 {
17                     currentLen++;
18                     currentNum++;
19                 }
20                 if(currentLen>maxSize)
21                 maxSize = currentLen;
22             }
23         }
24         return maxSize;               
25     }
26 };