LeetCode //C - 128. Longest Consecutive Sequence

128. Longest Consecutive Sequence

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

You must write an algorithm that runs in O(n) time.

Example 1:

Input: nums = [100,4,200,1,3,2]
Output: 4
Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.

Example 2:

Input: nums = [0,3,7,2,5,8,4,6,0,1]
Output: 9

Constraints:

  • 0 < = n u m s . l e n g t h < = 1 0 5 0 <= nums.length <= 10^5 0<=nums.length<=105
  • − 1 0 9 < = n u m s [ i ] < = 1 0 9 -10^9 <= nums[i] <= 10^9 −109<=nums[i]<=109

From: LeetCode

Link: 128. Longest Consecutive Sequence


Solution:

Ideas:

The idea behind this code is to find the length of the longest consecutive elements sequence in an unsorted array of integers. It does this by leveraging a hash table to achieve O(n) time complexity. Here's a step-by-step explanation of the code:

  1. Hash Table Creation: The code first creates a hash table to efficiently store and search for the numbers in the given array. The hash table is implemented using separate chaining, where each index in the table's array represents a linked list of hash nodes.

  2. Populating the Hash Table: The code iterates through the input array and inserts each number into the hash table. The key for each number is the number itself, and the index is calculated using the absolute value of the number modulo the table's size.

  3. Finding the Longest Consecutive Sequence: The main logic of the code iterates through the input array again, checking for the beginning of a consecutive sequence. It identifies the start of a sequence by looking for a number that doesn't have a predecessor (i.e., there's no (num - 1) in the hash table). Once the start of a sequence is found, it continues to check for consecutive numbers in the sequence, incrementing a counter for each successive number found.

  4. Checking for Consecutive Numbers: To check whether a number is part of a consecutive sequence, the code looks up the number in the hash table using the contains function. This enables efficient O(1) average-time lookups, allowing the code to quickly identify consecutive numbers in the sequence.

  5. Tracking the Longest Sequence: As the code identifies consecutive sequences, it keeps track of the length of the current sequence and updates the length of the longest sequence found so far. Once all numbers have been processed, the length of the longest consecutive sequence is returned.

  6. Memory Cleanup: Finally, the code includes logic to free the dynamically allocated memory for the hash table and its associated linked lists.

Code:
c 复制代码
struct HashNode {
    int key;
    struct HashNode *next;
};

struct HashTable {
    int size;
    struct HashNode **array;
};

struct HashTable* createHashTable(int size) {
    struct HashTable* table = (struct HashTable*)malloc(sizeof(struct HashTable));
    table->size = size;
    table->array = (struct HashNode**)malloc(sizeof(struct HashNode*) * size);
    for (int i = 0; i < size; i++) {
        table->array[i] = NULL;
    }
    return table;
}

void insert(struct HashTable *table, int key) {
    int index = (key < 0 ? -key : key) % table->size;
    struct HashNode *newNode = (struct HashNode*)malloc(sizeof(struct HashNode));
    newNode->key = key;
    newNode->next = table->array[index];
    table->array[index] = newNode;
}

bool contains(struct HashTable *table, int key) {
    int index = (key < 0 ? -key : key) % table->size;
    struct HashNode *current = table->array[index];
    while (current != NULL) {
        if (current->key == key) return true;
        current = current->next;
    }
    return false;
}

int longestConsecutive(int* nums, int numsSize) {
    if (numsSize == 0) return 0;

    struct HashTable *table = createHashTable(numsSize * 2);
    for (int i = 0; i < numsSize; i++) {
        insert(table, nums[i]);
    }

    int longestStreak = 0;
    for (int i = 0; i < numsSize; i++) {
        if (!contains(table, nums[i] - 1)) {
            int currentNum = nums[i];
            int currentStreak = 1;

            while (contains(table, currentNum + 1)) {
                currentNum += 1;
                currentStreak += 1;
            }

            if (currentStreak > longestStreak) {
                longestStreak = currentStreak;
            }
        }
    }

    // Free the allocated memory for the table
    for (int i = 0; i < table->size; i++) {
        struct HashNode* current = table->array[i];
        while (current != NULL) {
            struct HashNode* temp = current;
            current = current->next;
            free(temp);
        }
    }
    free(table->array);
    free(table);

    return longestStreak;
}
相关推荐
学习噢学个屁6 分钟前
基于STM32的交通灯设计—紧急模式、可调时间
c语言·stm32·单片机·嵌入式硬件
点云SLAM3 小时前
PyTorch 中.backward() 详解使用
人工智能·pytorch·python·深度学习·算法·机器学习·机器人
only-qi4 小时前
146. LRU 缓存
java·算法·缓存
潼心1412o4 小时前
C语言(长期更新)第15讲 指针详解(五):习题实战
c语言·开发语言
梁辰兴5 小时前
数据结构:排序
数据结构·算法·排序算法·c·插入排序·排序·交换排序
Lris-KK5 小时前
【Leetcode】高频SQL基础题--1731.每位经理的下属员工数量
sql·leetcode
野犬寒鸦5 小时前
力扣hot100:搜索二维矩阵 II(常见误区与高效解法详解)(240)
java·数据结构·算法·leetcode·面试
菜鸟得菜5 小时前
leecode kadane算法 解决数组中子数组的最大和,以及环形数组连续子数组的最大和问题
数据结构·算法·leetcode
楼田莉子6 小时前
C++算法专题学习——分治
数据结构·c++·学习·算法·leetcode·排序算法
一支鱼6 小时前
leetcode常用解题方案总结
前端·算法·leetcode