하나 [주제 카테고리]

해시 테이블

두 가지 [질문 난이도]

중간

세 [화제 번호]

128. 가장 긴 연속 시퀀스

네 [제목 설명]

정렬되지 않은 정수 배열 nums가 주어지면 가장 긴 연속 숫자 시퀀스의 길이를 찾습니다(시퀀스의 요소가 원래 배열에서 연속적일 필요는 없음).
이 문제를 해결하기 위해 O(n) 시간 복잡도를 갖는 알고리즘을 설계하고 구현하십시오.

다섯 [주제 예]

예 1:
- 입력: 숫자 = [100,4,200,1,3,2]
- 출력: 4
- 설명: 연속되는 가장 긴 수열은 [1, 2, 3, 4]입니다. 길이는 4입니다.
예 2:
- 입력: 숫자 = [0,3,7,2,5,8,4,6,0,1]
- 출력: 9

여섯 [주제 프롬프트]

$0 <= 숫자.길이 <= 10^5$
$10^9 <= 숫자[i] <= 10^9$

7가지 [문제 해결 아이디어]

해시 테이블 사용 아이디어
먼저 배열의 요소를 해시 테이블에 추가합니다. 이것의 목적은 중복을 제거하고 후속 계산을 용이하게 하는 것입니다.
그런 다음 해시 테이블의 각 요소를 순회하고 이 요소에서 시작하여 연속 배열을 계산하고 해시 테이블을 스캔합니다.
이렇게 하면 $이 문제를 풀기 위한 O (n)$ 시간복잡도
마지막으로 결과 반환

여덟 【시간 주파수】

시간 복잡도: $O (n)$ ， $n$ 은 들어오는 배열의 길이입니다.
공간 복잡도: $O (n)$ ， $n$ 은 들어오는 배열의 길이입니다.

나인 [코드 구현]

자바 언어 버전

class Solution {
    
    
    public int longestConsecutive(int[] nums) {
    
    
        HashSet<Integer> map = new HashSet<>();
        for(int i = 0;i < nums.length;i++){
    
    
            map.add(nums[i]);
        }
        int res = 0;
        for(int num : map){
    
    
            if(!map.contains(num - 1)){
    
    
                int curNum = num;
                int curLen = 1;
                while(map.contains(curNum + 1)){
    
    
                    curNum += 1;
                    curLen += 1;
                }
                res = Math.max(res, curLen);
            }
        }
        return res;
    }
}

C 언어 버전

struct HashNode
{
    
    
    int key;
    UT_hash_handle hh;
};

int longestConsecutive(int* nums, int numsSize)
{
    
    
    struct HashNode* map = NULL;
    struct HashNode* tempNode = NULL;
    for(int i = 0;i < numsSize;i++)
    {
    
    
        HASH_FIND_INT(map, &nums[i], tempNode);
        if(tempNode == NULL)
        {
    
    
            struct HashNode* newNode = (struct HashNode*)malloc(sizeof(struct HashNode));
            newNode->key = nums[i];
            HASH_ADD_INT(map, key, newNode);
        }
    }
    struct HashNode *val, *temp;
    int res = 0;
    HASH_ITER(hh, map, val, temp)
    {
    
    
        if(val != NULL)
        {
    
    
            int lastVal = val->key - 1;
            HASH_FIND_INT(map, &lastVal, tempNode);
            if(tempNode == NULL)
            {
    
    
                int curNum = val->key + 1;
                int curLen = 1;
                HASH_FIND_INT(map, &curNum, tempNode);
                while(tempNode != NULL)
                {
    
    
                    curNum += 1;
                    curLen += 1;
                    HASH_FIND_INT(map, &curNum, tempNode);
                }
                res = fmax(res, curLen);
            }
        }
    }
    HASH_ITER(hh, map, val, temp)
    {
    
    
        HASH_DEL(map, val);
        free(val);
    }
    return res;
}

파이썬 언어 버전

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        map = set(nums)
        res = 0
        for num in map:
            if num - 1 not in map:
                curNum = num
                curLen = 1
                while curNum + 1 in map:
                    curNum += 1
                    curLen += 1
                res = max(res, curLen)
        return res

C++ 언어 버전

class Solution {
    
    
public:
    int longestConsecutive(vector<int>& nums) {
    
    
        unordered_set<int> map;
        for(int i = 0;i < nums.size();i++){
    
    
            map.insert(nums[i]);
        }
        int res = 0;
        for(const int& num : map){
    
    
            if(!map.count(num - 1)){
    
    
                int curNum = num;
                int curLen = 1;
                while(map.count(curNum + 1)){
    
    
                    curNum += 1;
                    curLen += 1;
                }
                res = max(res, curLen);
            }
        }
        return res;
    }
};