leetcode128 最长连续序列

长沙有肥鱼2023-10-25 22:14

🚀🏆🍀 ✨👇👇👇 🌴🎄🎈🚀 🔥🔥🔥🌟🍀🎉🎉🎉🎉

python3哈希表不完整代码：🌟🌟🍀🎉🎉🎉

python 复制代码 
# -*- coding: utf-8 -*-
# @Time    : 2023/9/11 22:10
# @Author  : 长沙有肥鱼
# @FileName: 最长连续序列.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

class Solution:
    def longestConsecutive(self, nums):
        longest_streak = 0  # 定义最长连续序列的长度
        num_set = set(nums)  # 将所有数字放入一个集合中,去重
        for num in num_set:  # 如果当前的数是一个连续的的起点，统计这个连续序列的长度
            if num - 1 not in num_set:  # 如果当前数减去1不在连续序列中
                current_num = num
                current_streak = 1  # 连续序列的长度为1
                while(current_num + 1) in num_set:  # 如果当前数+1在连续序列中
                    current_num += 1  # 不断查找连续序列，直到num的下一个数组不存在于数组中
                    current_streak += 1
                longest_streak = max(longest_streak, current_streak)  # 更新最长连续序列的长度

        return longest_streak  # 返回连续最长序列的大小

python3哈希表完整代码：

python 复制代码 
# -*- coding: utf-8 -*-
# @Time    : 2023/9/11 22:10
# @Author  : 长沙有肥鱼
# @FileName: 最长连续序列.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

class Solution:
    def longestConsecutive(self, nums):
        longest_streak = 0  # 定义最长连续序列的长度
        num_set = set(nums)  # 将所有数字放入一个集合中,去重
        for num in num_set:  # 如果当前的数是一个连续的的起点，统计这个连续序列的长度
            if num - 1 not in num_set:  # 如果当前数减去1不在连续序列中
                current_num = num
                current_streak = 1  # 连续序列的长度为1
                while(current_num + 1) in num_set:  # 如果当前数+1在连续序列中
                    current_num += 1  # 不断查找连续序列，直到num的下一个数组不存在于数组中
                    current_streak += 1
                longest_streak = max(longest_streak, current_streak)  # 更新最长连续序列的长度

        return longest_streak  # 返回连续最长序列的大小


# 示例用法
nums = [100, 4, 200, 1, 3, 2]
solution = Solution()  # 实例化Solution类
result = solution.longestConsecutive(nums)  # 调用twoSum函数
print("最长连续序列长度为:", result)

c++哈希表不完整代码：

python 复制代码 
// 定义一个名为 Solution 的类
class Solution{
public:
    int longestConsecutive(vector<int> &nums){
        int longest_streak = 0;//定义最长连续序列的长度
        // 将所有数字放入一个无序集合中去重
        unordered_set<int> num_set(nums.begin(),nums.end());
        //如果当前的数是一个连续序列的起点，统计这个连续序列的长度
        for(int num : nums){
            //如果集合 num_set 中不存在 num - 1 这个元素,即当前数字 num 是一个连续序列的起点
            if (num_set.find(num - 1) == num_set.end()){
                int current_num = num;
                int current_streak = 1;
                while(num_set.find(current_num + 1) != num_set.end()){
                    current_num += 1; //当前数+1
                    current_streak += 1; //当前连续序列大小+1
                }
                longest_streak = max(longest_streak, current_streak);//更新最长连续序列的长度
            }
        }
        return longest_streak;//更新最长连续序列的长度
    }
};
python 复制代码 
// 定义一个名为 Solution 的类
class Solution{
public:
    int longestConsecutive(vector<int> &nums){
        int longest_streak = 0;//定义最长连续序列的长度
        // 将所有数字放入一个无序集合中去重
        unordered_set<int> num_set(nums.begin(),nums.end());
        //如果当前的数是一个连续序列的起点，统计这个连续序列的长度
        for(int num : nums){
            //如果集合 num_set 中不存在 num - 1 这个元素,即当前数字 num 是一个连续序列的起点
            if (!num_set.count(num - 1)){
                int current_streak = 1;
                while(num_set.count(num++)){
                    num += 1; //当前数+1
                    longest_streak += 1; //当前连续序列大小+1
                }
                longest_streak = max(longest_streak, current_streak);//更新最长连续序列的长度
            }
        }
        return longest_streak;//更新最长连续序列的长度
    }
};

c++哈希表完整代码：

python 复制代码 
// -*- coding: utf-8 -*-
// @Time    : 2023/9/11 22:45
// @Author  : 长沙有肥鱼
// @FileName: 最长连续序列.cpp
// @Software: CLion
// @Blog    : https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

#include<iostream>// 输入输出流库
#include<vector> // 向量容器库
#include<algorithm>
#include<unordered_set>

using namespace std;
// 定义一个名为 Solution 的类
class Solution{
public:
    int longestConsecutive(vector<int> &nums){
        int longest_streak = 0;//定义最长连续序列的长度
        // 将所有数字放入一个无序集合中去重
        unordered_set<int> num_set(nums.begin(),nums.end());
        //如果当前的数是一个连续序列的起点，统计这个连续序列的长度
        for(int num : nums){
            //如果集合 num_set 中不存在 num - 1 这个元素,即当前数字 num 是一个连续序列的起点
            if (num_set.find(num - 1) == num_set.end()){
                int current_num = num;
                int current_streak = 1;
                while(num_set.find(current_num + 1) != num_set.end()){
                    current_num += 1; //当前数+1
                    longest_streak += 1; //当前连续序列大小+1
                }
                longest_streak = max(longest_streak, current_streak);//更新最长连续序列的长度
            }
        }
        return longest_streak;//更新最长连续序列的长度
    }
};

int main(){
    std::vector<int> nums = {100, 4, 200, 1, 3, 2}; // 定义一个整数向量 nums
    Solution solution;
    int result = solution.longestConsecutive(nums);// 调用 longestConsecutive 函数，传入 nums
    cout<<"最长连续序列长度为:"<<result<<endl;// 输出最长连续序列的长度
    return 0;
}
python 复制代码 
// -*- coding: utf-8 -*-
// @Time    : 2023/9/11 22:45
// @Author  : 长沙有肥鱼
// @FileName: 最长连续序列.cpp
// @Software: CLion
// @Blog    : https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

#include<iostream>// 输入输出流库
#include<vector> // 向量容器库
#include<algorithm> // 标准算法库
#include<unordered_set> // 无序集合库

using namespace std; // 使用标准命名空间

// 定义一个名为 Solution 的类
class Solution{
public:
    int longestConsecutive(vector<int> &nums){ // 定义一个函数，接收一个整数向量的引用作为参数
        int longest_streak = 0;//定义最长连续序列的长度

        // 将所有数字放入一个无序集合中去重
        unordered_set<int> num_set(nums.begin(),nums.end());

        //如果当前的数是一个连续序列的起点，统计这个连续序列的长度
        for(int num : nums){ // 对于向量中的每一个元素
            //如果集合 num_set 中不存在 num - 1 这个元素,即当前数字 num 是一个连续序列的起点
            if (!num_set.count(num - 1)){ // 如果 num-1 不在 num_set 中
                int current_num = num; // 将当前数赋给 current_num
                int current_streak = 1; // 当前连续序列的长度为1
                while(num_set.count(current_num + 1)){ // 当 current_num + 1 在 num_set 中
                    current_num += 1; //当前数+1
                    current_streak += 1; //当前连续序列大小+1
                }
                longest_streak = max(longest_streak, current_streak); // 更新最长连续序列的长度
            }
        }
        return longest_streak; // 返回最长连续序列的长度
    }
};

int main(){ // 主函数
    std::vector<int> nums = {0, 3, 7, 2, 5, 8, 4, 6, 0, 1}; // 定义一个整数向量 nums

    Solution solution; // 实例化Solution类
    int result = solution.longestConsecutive(nums); // 调用 longestConsecutive 函数，传入 nums
    cout<<"最长连续序列长度为:"<<result<<endl; // 输出最长连续序列的长度
    return 0; // 返回0，表示程序正常结束
}
python 复制代码 
#include <iostream> // 包含输入输出流库
#include <vector>   // 包含向量容器库
#include <unordered_set> // 包含无序集合库

using namespace std; // 使用标准命名空间

// 定义一个名为 Solution 的类
class Solution{
public:
    int longestConsecutive(vector<int>& nums) {// 定义一个函数，接收一个整数向量的引用作为参数
        unordered_set<int> numSet(nums.begin(), nums.end()); // 将所有数字放入一个无序集合中去重
        int longestStreak = 0;//定义最长连续序列的长度
        //如果当前的数是一个连续序列的起点，统计这个连续序列的长度
        for (int num : nums) {
            //如果集合 num_set 中不存在 num - 1 这个元素,即当前数字 num 是一个连续序列的起点
            if (numSet.find(num - 1) == numSet.end()) {// 如果 num-1 不在 num_set 中
                int currentNum = num; // 将当前数赋给 current_num
                int currentStreak = 1;// 当前连续序列的长度为1

                // 继续查找连续序列中的下一个数字
                while (numSet.find(currentNum + 1) != numSet.end()) {// 当 current_num + 1 在 num_set 中
                    currentNum += 1;//当前数+1
                    currentStreak += 1;//当前连续序列大小+1
                }

                // 更新最长连续序列的长度
                longestStreak = max(longestStreak, currentStreak);
            }
        }

        return longestStreak;// 返回最长连续序列的长度
    }
};


int main(){ // 主函数
    std::vector<int> nums = {0, 3, 7, 2, 5, 8, 4, 6, 0, 1}; // 定义一个整数向量 nums

    Solution solution; // 实例化Solution类
    int result = solution.longestConsecutive(nums); // 调用 longestConsecutive 函数，传入 nums
    cout<<"最长连续序列长度为:"<<result<<endl; // 输出最长连续序列的长度
    return 0; // 返回0，表示程序正常结束
}

Java哈希表不完整代码：

python 复制代码 
class Solution {
    public static int longestConsecutive(int[] nums) { // 定义一个函数,接收一个整数数组作为参数
        HashSet<Integer> num_set = new HashSet<>(); // 创建一个HashSet，用于存储数字
        for (int num : nums) {
            num_set.add(num); // 将所有数字放入集合中去重
        }
        int longest_streak = 0; // 定义最长连续序列的长度

        // 如果当前的数是一个连续序列的起点,统计这个连续序列的长度
        for (int num : nums) { // 对于数组中的每一个元素
            // 如果集合 num_set 中不存在 num - 1 这个元素,即当前数字 num 是一个连续序列的起点
            if (!num_set.contains(num - 1)) { // 如果 num-1 不在 num_set 中
                int current_num = num; // 将当前数赋给 current_num
                int current_streak = 1; // 当前连续序列的长度为1
                while (num_set.contains(current_num + 1)) { // 当 current_num 在 num_set 中
                    current_num += 1;//当签数+1
                    current_streak += 1; // 当前连续序列大小+1
                }
                longest_streak = Math.max(longest_streak, current_streak); // 更新最长连续序列的长度
            }
        }
        return longest_streak; // 返回最长连续序列的长度
    }
}
python 复制代码 
class Solution {
    public static int longestConsecutive(int[] nums) { // 定义一个函数,接收一个整数数组作为参数
        HashSet<Integer> num_set = new HashSet<>(); // 创建一个HashSet，用于存储数字
        for (int num : nums) {
            num_set.add(num); // 将所有数字放入集合中去重
        }
        int longest_streak = 0; // 定义最长连续序列的长度

        // 如果当前的数是一个连续序列的起点,统计这个连续序列的长度
        for (int num : nums) { // 对于数组中的每一个元素
            // 如果集合 num_set 中不存在 num - 1 这个元素,即当前数字 num 是一个连续序列的起点
            if (!num_set.contains(num - 1)) { // 如果 num-1 不在 num_set 中
                int current_num = num; // 将当前数赋给 current_num
                int current_streak = 1; // 当前连续序列的长度为1
                while (num_set.contains(++current_num)) { // 当 current_num 在 num_set 中
                    current_streak += 1; // 当前连续序列大小+1
                }
                longest_streak = Math.max(longest_streak, current_streak); // 更新最长连续序列的长度
            }
        }
        return longest_streak; // 返回最长连续序列的长度
    }
}

Java哈希表完整代码：

python 复制代码 
/**
 * @Time : 2023/9/11 23:22
 * @Author : 长沙有肥鱼
 * @FileName: longestConsecutive.java
 * @Software: IntelliJ IDEA
 * @Blog ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343 22
 **/

import java.util.HashSet;

public class longestConsecutive {
    public static int longestConsecutive(int[] nums) {
        HashSet<Integer> numSet = new HashSet<>(); // 创建一个哈希集合，用于存储数字
        for (int num : nums) {
            numSet.add(num); // 将所有数字放入集合中，去重
        }

        int longestStreak = 0;

        for (int num : nums) {
            if (!numSet.contains(num - 1)) { // 只考虑当前数字是一个连续序列的起点
                int currentNum = num;
                int currentStreak = 1;

                while (numSet.contains(currentNum + 1)) { // 继续查找连续序列中的下一个数字
                    currentNum += 1;
                    currentStreak += 1;
                }

                longestStreak = Math.max(longestStreak, currentStreak); // 更新最长连续序列的长度
            }
        }

        return longestStreak;
    }

    public static void main(String[] args) {
        int[] nums = {0, 3, 7, 2, 5, 8, 4, 6, 0, 1}; // 定义一个整数数组 nums
        int result = longestConsecutive(nums); // 调用 longestConsecutive 函数，传入 nums

        System.out.println("最长连续序列长度为: " + result); // 输出最长连续序列的长度
    }
}
python 复制代码 
/**
 * @Time : 2023/9/11 23:22
 * @Author : 长沙有肥鱼
 * @FileName: longestConsecutive.java
 * @Software: IntelliJ IDEA
 * @Blog ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343
 **/

import java.util.HashSet; // 导入HashSet类

public class longestConsecutive {
    public static int longestConsecutive(int[] nums) { // 定义一个函数,接收一个整数数组作为参数
        HashSet<Integer> num_set = new HashSet<>(); // 创建一个HashSet，用于存储数字
        for (int num : nums) {
            num_set.add(num); // 将所有数字放入集合中去重
        }
        int longest_streak = 0; // 定义最长连续序列的长度

        // 如果当前的数是一个连续序列的起点,统计这个连续序列的长度
        for (int num : nums) { // 对于数组中的每一个元素
            // 如果集合 num_set 中不存在 num - 1 这个元素,即当前数字 num 是一个连续序列的起点
            if (!num_set.contains(num - 1)) { // 如果 num-1 不在 num_set 中
                int current_num = num; // 将当前数赋给 current_num
                int current_streak = 1; // 当前连续序列的长度为1
                while (num_set.contains(++current_num)) { // 当 current_num 在 num_set 中
                    current_streak += 1; // 当前连续序列大小+1
                }
                longest_streak = Math.max(longest_streak, current_streak); // 更新最长连续序列的长度
            }
        }
        return longest_streak; // 返回最长连续序列的长度
    }

    public static void main(String[] args) {
        int[] nums = {0, 3, 7, 2, 5, 8, 4, 6, 0, 1}; // 定义一个整数数组 nums
        int result = longestConsecutive(nums); // 调用 longestConsecutive 函数,传入 nums
        System.out.println("最长连续序列的长度为:" + result); // 输出最长连续序列的长度
    }
}
相关推荐
一个通信老学姐6 小时前
专业130+总400+武汉理工大学855信号与系统考研经验电子信息与通信工程，真题，大纲，参考书。
考研·信息与通信·信号处理·1024程序员节
力姆泰克7 小时前
看电动缸是如何提高农机的自动化水平
大数据·运维·服务器·数据库·人工智能·自动化·1024程序员节
力姆泰克7 小时前
力姆泰克电动缸助力农业机械装备，提高农机的自动化水平
大数据·服务器·数据库·人工智能·1024程序员节
程思扬7 小时前
为什么Uptime+Kuma本地部署与远程使用是网站监控新选择？
linux·服务器·网络·经验分享·后端·网络协议·1024程序员节
转世成为计算机大神8 小时前
网关 Spring Cloud Gateway
java·网络·spring boot·1024程序员节
paopaokaka_luck8 小时前
基于Spring Boot+Vue的助农销售平台(协同过滤算法、限流算法、支付宝沙盒支付、实时聊天、图形化分析)
java·spring boot·小程序·毕业设计·mybatis·1024程序员节
幼儿园园霸柒柒9 小时前
第七章： 7.3求一个3*3的整型矩阵对角线元素之和
c语言·c++·算法·矩阵·c#·1024程序员节
好想有猫猫9 小时前
【51单片机】串口通信原理 + 使用
c语言·单片机·嵌入式硬件·51单片机·1024程序员节
2403_875736879 小时前
道品科技的水肥一体化智能灌溉：开启现代农业的创新征程
大数据·人工智能·1024程序员节
小言从不摸鱼11 小时前
【NLP自然语言处理】深入解析Encoder与Decoder模块：结构、作用与深度学习应用
人工智能·深度学习·神经网络·机器学习·自然语言处理·transformer·1024程序员节
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play