🚀🏆🍀✨👇👇👇🌴🎄🎈🚀🔥🔥🔥🌟🍀🎉🎉🎉🎉
python3哈希表不完整代码：🌟🌟🍀🎉🎉🎉
# -*- 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哈希表完整代码：
# -*- 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++哈希表不完整代码：
// 定义一个名为 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;//更新最长连续序列的长度
}
};
// 定义一个名为 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++哈希表完整代码：
// -*- 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;
}
// -*- 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，表示程序正常结束
}
#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哈希表不完整代码：
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; // 返回最长连续序列的长度
}
}
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哈希表完整代码：
/**
* @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); // 输出最长连续序列的长度
}
}
/**
* @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); // 输出最长连续序列的长度
}
}
165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
