zoukankan html css js c++ java

[LintCode] Longest Consecutive Sequence

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

Clarification

Your algorithm should run in O(n) complexity.

Example

Given [100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.

Solution 1. O(n * log n) runtime using sorting

Algorithm:

1. sort the array;

2. iterate through the sorted array and process each element in the following 3 possible cases.

　　a. num[i] - num[i - 1] == 1, currMaxLen++;

　　b. num[i] - num[i - 1] != 1 && num[i] != num[i - 1], the current sequence discontinues, reset currMaxLen to 1;

　　c. num[i] == num[i - 1], the current sequence should continue, do nothing.

 1 public class Solution {
 2     public int longestConsecutive(int[] num) {
 3         if(num == null || num.length == 0){
 4             return 0;
 5         }
 6         Arrays.sort(num);
 7         int maxLen = 1, currMaxLen = 1;
 8         for(int i = 1; i < num.length; i++){
 9             if(num[i] - num[i - 1] == 1){
10                 currMaxLen++;
11             }
12             else if(num[i] != num[i - 1]){
13                 currMaxLen = 1;
14             }
15             maxLen = Math.max(maxLen, currMaxLen);
16         }
17         return maxLen;
18     }
19 }

Solution 2. O(n * log n) runtime, O(n) space using min priority queue.

Similiarly with solution 1, we can use a min pq to replace the effect of sorting.

 1 public class Solution {
 2     public int longestConsecutive(int[] num) {
 3         if(num == null || num.length == 0){
 4             return 0;
 5         }
 6         PriorityQueue<Integer> minPq = new PriorityQueue<Integer>(num.length);
 7         for(int i = 0; i < num.length; i++){
 8             minPq.add(num[i]);
 9         }
10         int prevMin = Integer.MAX_VALUE, currMin = Integer.MIN_VALUE;
11         int currMaxLen = 1, maxLen = Integer.MIN_VALUE;
12         while(minPq.size() != 0){
13             currMin = minPq.poll();
14             if(currMin - prevMin == 1){
15                 currMaxLen++;
16             }
17             else if(currMin != prevMin){
18                 currMaxLen = 1;
19             }
20             prevMin = currMin;
21             maxLen = Math.max(maxLen, currMaxLen);
22         }
23         return maxLen;
24     }
25 }

Solution 3. O(n) runtime, O(n) space, Using HashSet

Algorithm: Store all elements into a hash set, thus only unique elements are stored.

Iterate through all elements in num. For each num[i], go down and up to find the longest

consecutive sequence that has num[i] in it. In each iteration, delete all the elements

that appear in the current consecutive sequence. Doing this makes this algorithm more

efficient as it will not redudantly consider the same sequence more than once.

 1 public class Solution {
 2     public int longestConsecutive(int[] num) {
 3         if(num == null || num.length == 0){
 4             return 0;
 5         } 
 6         HashSet<Integer> set = new HashSet<Integer>();
 7         for(int i = 0; i < num.length; i++){
 8             set.add(num[i]);
 9         }
10         int longest = 0;
11         for(int i = 0; i < num.length; i++){
12             int down = num[i] - 1;
13             while(set.contains(down)){
14                 set.remove(down);
15                 down--;
16             }
17             int up = num[i] + 1;
18             while(set.contains(up)){
19                 set.remove(up);
20                 up++;
21             }
22             set.remove(num[i]);
23             longest = Math.max(longest, up - down - 1);
24         }
25         return longest;
26     }
27 }