1 不需要排序算法。使用表插入代替了排序，无序，只需要检查是否存在数据。
自己方法1 不合格 排序算法 快速排序 时间O（n2）
class Solution {
public:
int longestConsecutive(vector<int>& nums) {
if (nums.empty()) return 0;
//1 数组排序
// 2 遍历 i 0-(length(num)-1)
// num[i+1]-num[i]==1 创建map 添加到后面
// 否则单独创建一个 map列表
// 最后统计最长的队列
for(int i =0;i<nums.size();++i){
for(int j =i+1;j<nums.size();++j){
if(nums[j]<nums[i]){
int temp=nums[j];
nums[j]=nums[i];
nums[i]=temp;
}
}
//std::cout << nums[i] << " ";
}
//std::cout <<std::endl;
// std::unordered_map<int,vector<int>> umap;
int tmep_=1;
int max_=1;
for(int i =0;i<(nums.size()-1);++i){
// std::cout<< i << " "<< nums[i+1]<< " - " << nums[i] <<std::endl;
if((nums[i+1]-nums[i])==1){
tmep_=tmep_+1;
//std::cout<< "tmep_ " <<tmep_ <<std::endl;
if(tmep_>max_){
max_=tmep_;
}
}
else if(nums[i+1]==nums[i]){
continue;
}
else{
if(tmep_>max_){
max_=tmep_+1;
}
tmep_=1;
}
}
return max_;
}
};
自己方法2 不合格 插入排序 时间O(N2) 且多次交换效率低
自己的方法3 不合格 标砖插入排序，直接赋值 速度更快 但还是O(n2)
void Sort2(vector<int>& nums){
for(int j=0;j< nums.size()-1;++j){
int i=j;
while( nums[i] > nums[i+1]){
int temp =nums[i+1];
nums[i+1] =nums[i];
nums[i] =temp;
--i;
if(i<0)break;
}
}
}
void insertionSort(vector<int>& nums){
for(int i=1;i< nums.size();++i){
int key = nums[i];
int j=i-1;
while(j>=0 && nums[j]>key){
nums[j+1] = nums[j];
j--;
}
nums[j+1]=key;
}
}
方法3-2 排序方法，使用官方的sort和自己实现的快速+插入排序+优化策略
class Solution {
public:
// 插入排序（用于小规模数据）
void insertionSort(std::vector<int>& arr, int low, int high) {
for (int i = low + 1; i <= high; ++i) {
int key = arr[i];
int j = i - 1;
while (j >= low && arr[j] > key) {
arr[j + 1] = arr[j];
--j;
}
arr[j + 1] = key;
}
}
// 三数取中法选择基准
int medianOfThree(std::vector<int>& arr, int low, int high) {
int mid = low + (high - low) / 2;
// 确保 arr[low] <= arr[mid] <= arr[high]
if (arr[low] > arr[mid]) std::swap(arr[low], arr[mid]);
if (arr[low] > arr[high]) std::swap(arr[low], arr[high]);
if (arr[mid] > arr[high]) std::swap(arr[mid], arr[high]);
// 将中位数放到 high 位置（Lomuto 分区方案）
std::swap(arr[mid], arr[high]);
return arr[high];
}
// 分区函数（Lomuto 方案 + 随机化基准）
int partition(std::vector<int>& arr, int low, int high) {
// 随机选择基准并交换到末尾
int randomIndex = low + rand() % (high - low + 1);
std::swap(arr[randomIndex], arr[high]);
// 三数取中法优化（可选，此处注释掉以单独测试随机化）
// int pivot = medianOfThree(arr, low, high);
int pivot = arr[high];
int i = low - 1; // i 是小于基准的区域的右边界
for (int j = low; j < high; ++j) {
if (arr[j] < pivot) {
++i;
std::swap(arr[i], arr[j]);
}
}
std::swap(arr[i + 1], arr[high]); // 将基准放到正确位置
return i + 1;
}
// 快速排序主函数（尾递归优化）
void quickSort(std::vector<int>& arr, int low, int high) {
const int INSERTION_THRESHOLD = 16; // 小数组阈值
while (low < high) {
if (high - low + 1 <= INSERTION_THRESHOLD) {
insertionSort(arr, low, high);
break;
}
int pivotIndex = partition(arr, low, high);
// 尾递归优化：先处理较短的子数组
if (pivotIndex - low < high - pivotIndex) {
quickSort(arr, low, pivotIndex - 1);
low = pivotIndex + 1;
} else {
quickSort(arr, pivotIndex + 1, high);
high = pivotIndex - 1;
}
}
}
int longestConsecutive(vector<int>& nums) {
if (nums.empty()) return 0;
// 自己实现的排序
quickSort(nums, 0, nums.size() - 1);
// 官方的排序
std::sort(arrCopy.begin(), arrCopy.end());
// std::unordered_map<int,vector<int>> umap;
int tmep_=1;
int max_=1;
for(int i =0;i<(nums.size()-1);++i){
// std::cout<< i << " "<< nums[i+1]<< " - " << nums[i] <<std::endl;
if((nums[i+1]-nums[i])==1){
tmep_=tmep_+1;
//std::cout<< "tmep_ " <<tmep_ <<std::endl;
if(tmep_>max_){
max_=tmep_;
}
}
else if(nums[i+1]==nums[i]){
continue;
}
else{
if(tmep_>max_){
max_=tmep_+1;
}
tmep_=1;
}
}
return max_;
}
};
方法4 非排序方法 map实现
int test_map(vector<int>& nums){
std::map<int,int> map_;
for(int i=0;i<nums.size();i++){
//map_[nums[i]]=nums[i];
//auto ok_= map_.insert({nums[i],nums[i]});
map_.emplace(nums[i],nums[i]);
// if(ok_.second){
// //std::cout<<"插入成功"<<std::endl;
// }
// else{
// //std::cout<<"插入失败，已经存在"<< " " << i <<std::endl;
// }
}
int current_=1;
int cur_max_num=0;
int all_max_num=0;
for(auto &pair :map_ ){
cur_max_num=1;
if(!map_.contains(pair.first-1)){
current_=pair.first+1;
while(map_.contains(current_)){
current_++;
cur_max_num++;
}
}
all_max_num=std::max(all_max_num,cur_max_num);
}
return all_max_num;
}
方法5 unordered_map实现
class Solution {
public:
int test_map(vector<int>& nums){
std::map<int,int> map_;
for(int i=0;i<nums.size();i++){
//map_[nums[i]]=nums[i];
//auto ok_= map_.insert({nums[i],nums[i]});
map_.emplace(nums[i],nums[i]);
// if(ok_.second){
// //std::cout<<"插入成功"<<std::endl;
// }
// else{
// //std::cout<<"插入失败，已经存在"<< " " << i <<std::endl;
// }
}
int current_=1;
int cur_max_num=0;
int all_max_num=0;
for(auto &pair :map_ ){
cur_max_num=1;
if(!map_.contains(pair.first-1)){
current_=pair.first+1;
while(map_.contains(current_)){
current_++;
cur_max_num++;
}
}
all_max_num=std::max(all_max_num,cur_max_num);
}
return all_max_num;
}
int test_unorder_map(vector<int>& nums){
std::unordered_map<int,int> map_;
for(int i=0;i<nums.size();i++){
//map_[nums[i]]=nums[i];
auto ok_= map_.insert({nums[i],nums[i]});
// if(ok_.second){
// //std::cout<<"插入成功"<<std::endl;
// }
// else{
// //std::cout<<"插入失败，已经存在"<< " " << i <<std::endl;
// }
}
int current_=1;
int cur_max_num=0;
int all_max_num=0;
for(auto &pair :map_ ){
cur_max_num=1;
if(!map_.contains(pair.first-1)){
current_=pair.first+1;
while(map_.contains(current_)){
current_++;
cur_max_num++;
}
}
all_max_num=std::max(all_max_num,cur_max_num);
}
return all_max_num;
}
int longestConsecutive(vector<int>& nums) {
// int all_max_num = test_map(nums);
int all_max_num = test_unorder_map(nums);
return all_max_num;
}
};
方法6 unordered_set
class Solution {
public:
int test_map(vector<int>& nums){
std::map<int,int> map_;
for(int i=0;i<nums.size();i++){
//map_[nums[i]]=nums[i];
//auto ok_= map_.insert({nums[i],nums[i]});
map_.emplace(nums[i],nums[i]);
// if(ok_.second){
// //std::cout<<"插入成功"<<std::endl;
// }
// else{
// //std::cout<<"插入失败，已经存在"<< " " << i <<std::endl;
// }
}
int current_=1;
int cur_max_num=0;
int all_max_num=0;
for(auto &pair :map_ ){
cur_max_num=1;
if(!map_.contains(pair.first-1)){
current_=pair.first+1;
while(map_.contains(current_)){
current_++;
cur_max_num++;
}
}
all_max_num=std::max(all_max_num,cur_max_num);
}
return all_max_num;
}
int test_unorder_map(vector<int>& nums){
std::unordered_map<int,int> map_;
for(int i=0;i<nums.size();i++){
//map_[nums[i]]=nums[i];
auto ok_= map_.insert({nums[i],nums[i]});
// if(ok_.second){
// //std::cout<<"插入成功"<<std::endl;
// }
// else{
// //std::cout<<"插入失败，已经存在"<< " " << i <<std::endl;
// }
}
int current_=1;
int cur_max_num=0;
int all_max_num=0;
for(auto &pair :map_ ){
cur_max_num=1;
if(!map_.contains(pair.first-1)){
current_=pair.first+1;
while(map_.contains(current_)){
current_++;
cur_max_num++;
}
}
all_max_num=std::max(all_max_num,cur_max_num);
}
return all_max_num;
}
int test_unordered_set(vector<int>& nums){
std::unordered_set<int> map_;
for(int i=0;i<nums.size();i++){
//map_[nums[i]]=nums[i];
auto ok_= map_.insert(nums[i]);
}
int current_=1;
int cur_max_num=0;
int all_max_num=0;
for(auto &pair :map_ ){
cur_max_num=1;
if(!map_.contains(pair-1)){
current_=pair+1;
while(map_.contains(current_)){
current_++;
cur_max_num++;
}
}
all_max_num=std::max(all_max_num,cur_max_num);
}
return all_max_num;
}
int longestConsecutive(vector<int>& nums) {
int all_max_num=0;
// int all_max_num = test_map(nums);
// all_max_num = test_unorder_map(nums);
all_max_num = test_unordered_set(nums);
return all_max_num;
}
};
参考1 使用官方sort排序 满足
官方2
class Solution {
public:
int longestConsecutive(vector<int>& nums) {
unordered_set<int> num_set;
for (const int& num : nums) {
num_set.insert(num);
}
int longestStreak = 0;
for (const int& num : num_set) {
if (!num_set.count(num - 1)) {
int currentNum = num;
int currentStreak = 1;
while (num_set.count(currentNum + 1)) {
currentNum += 1;
currentStreak += 1;
}
longestStreak = max(longestStreak, currentStreak);
}
}
return longestStreak;
}
};
作者：力扣官方题解
链接：https://leetcode.cn/problems/longest-consecutive-sequence/solutions/276931/zui-chang-lian-xu-xu-lie-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
浙公网安备 33010602011771号