最长连续序列长度

描述：给定一个无序数组，如｛7，10，1，9，5，3，4，2，8｝。最长连续序列为｛1，2，3，4，5｝，返回length=5。

思路一：先排序，再以此以每一个元素为起点更新递增序列长度。时间复杂度为平方级。

class Solution{
public:
    int length(int A[],int n)
    {
    	if(n==0) return 0;
		quickSort(A,0,n-1);
    	int max=1;
    	for(int i=0;i<n;i++)
    	{
    		int tmp=1;
			while(A[i+1]==A[i]+1)
			{
				tmp++;
				i++;
			}
			max=max>tmp?max:tmp;
		}
		return max;
	}
private:
	static void quickSort(int A[],int first,int last)
	{
		int key=A[first];
		int i=first;
		int j=last;
		while(i<j)
		{
			while(i<j&&A[j]>=key)j--;
			A[i]=A[j];
			while(i<j&&A[i]<=key)i++;
			A[j]=A[i];
		}
		A[i]=key;
		quickSort(A,first,i-1);
		quickSort(A,i+1,last);
    }
   
}; 

思路二：先排序，借用动态规划思想，申请数组dp[n],dp[i]表示从i为终点最长连续序列长度。时间复杂度为快排时间，空间复杂度为线性。

class Solution{
public:
    int length(int A[],int n)
    {
    	if(n==0) return 0;
		quickSort(A,0,n-1);
    	int *dp=(int *)malloc(sizeof(int)*(n+1));
    	dp[0]=1;
    	int max=1;
    	for(int i=1;i<n;i++)
    	{
    		dp[i]=A[i]==A[i-1]+1?dp[i-1]+1:1;
    		max=max>dp[i]?max:dp[i];
		}
		return max;
	}
private:
	static void quickSort(int A[],int first,int last)
	{
		int key=A[first];
		int i=first;
		int j=last;
		while(i<j)
		{
			while(i<j&&A[j]>=key)j--;
			A[i]=A[j];
			while(i<j&&A[i]<=key)i++;
			A[j]=A[i];
		}
		A[i]=key;
		quickSort(A,first,i-1);
		quickSort(A,i+1,last);
    }
   
}; 

思路三：不做排序处理，使用哈希表记录数值出现情况，并依次查找哈希表中每个key左右连续情况，即时更新。时间复杂度为线性，空间复杂度为线性。

#include<map>
class Solution{
public:
    int length(int A[],int n)
    {
    	if(n==0) return 0;
		map(int,bool) hash;
		for(int i=0;i<n;i++)
		{
			hash[A[i]]=false;
		}
     	int max=1;
    	for(int i=0;i<n;i++)
    	{
    		if(hash[A[i]])continue;//避免重复计算 
    		hash[A[i]]=true;
    		int tmp=1;
    		for(int j=A[i]+1;hash.find(j)!=hash.end();j++)//若能在hash中找到A[i]左右值作为key，则连续长度tmp增1 
    		{
    			hash[j]=true;
    			tmp++;
			}
			for(int j=A[i]-1;hash.find(j)!=hash.end();j--)
			{
				hash[j]=true;
				tmp++;
			}
			max=max>tmp?max:tmp;
		}
		return max;
	}
};