LeetCode高频100题刷题笔记（十五）排序算法

已于 2023-08-01 14:51:14 修改
阅读量146 收藏
点赞数
分类专栏： LeetCode刷题专栏 文章标签： leetcode 算法
于 2023-04-18 09:27:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29355253/article/details/130128434
版权

基础知识

算法名称描述（升序）时间复杂度空间复杂度稳定性
冒泡从无序区通过不断交换找出大元素放到有序区前面（无序， 有序）O(n^2)O(1)√
选择从无序区找最小的元素放到有序区后面（有序， 无序）O(n^2)O(1)×
插入把无序区的第一个元素插到有序区的合适位置（有序， 无序）O(n^2)O(1)√
希尔每一轮按照事先决定的间隔插入排序，间隔依次缩小直至为1（如0123 0123 0123 …，初始间隔为4，数字相同代表属于同一插入排序组）O(nlogn)O(1)×
归并分而治之：（分）把数据逐级分为两段，直至仅有1个数字返回，（治）从两段中逐个选最小的放入新数据段末尾O(nlogn)O(n)√
快速挑选基准元素 base，初始可选左基 left / 右基 right，< 基放前，> 基放后， = 选左基就跟左，右基就跟右，形如（小，基，大），从 base 位置切割成两个小数组（不含 base），利用递归对这两个小数组进行同样的操作，直至数组大小为1。（左基先移右，右基先移左，未遇就交换，相遇就是基）O(nlogn)O(logn)×
堆按层序初始化并构建大根堆，从堆顶把根移出放入有序区前，再恢复大根堆（无序，有序）。最大堆/大根堆：完全二叉树，非叶节点的值大于其左右孩子节点的值O(nlogn)O(1)×
计数用数组元素作为下标，统计某元素的个数 ，再把统计数据从小到大汇总起来O(n+k)O(k)√
桶将一组数据分到几个有序的桶里，每个桶里的数据单独排序，排序后再顺序倒出每个桶内元素O(n+k)O(n+k)√
基数先以个位数的大小来对数据进行排序，接着以十位数、百位数…以某位数进行排序的时候是用桶排实现O(nk)O(n+k)√

代码（C++）：

1.冒泡

class Solution {
public:
    vector<int> bubbleSort(vector<int>& nums) {
    	int n = nums.size();
        for (int i = 0; i < n; i++) {
        	for (int j = 0; j < n - i - 1; j++) {
        		if (nums[j] > nums[j + 1]) {
        			swap(nums[j], nums[j + 1]);
        		}
        	}
        }
        return nums;
    }
};

2.选择

class Solution {
public:
    vector<int> selectSort(vector<int>& nums) {
    	int n = nums.size();
        for (int i = 0; i < n - 1; i++) {
        	int min_idx = nums[i];
        	for (int j = i + 1; j < n; j++) {
        		if (nums[j] < nums[min_idx]) {
        			min_idx = j;
        		}
        	}
        	if (min_idx != i) swap(nums[i], nums[min_idx]); 
        }
        return nums;
    }
};

3.插入

class Solution {
public:
    vector<int> insertSort(vector<int>& nums) {
    	int n = nums.size();
        for (int i = 1; i < n; i++) {
        	int base = nums[i];
        	int j = i - 1;
        	while (j >= 0 && base < nums[j]) {
        		nums[j + 1] = nums[j];
        		j--;
        	}
        	nums[j + 1] = base;
        }
        return nums;
    }
};

4.希尔

class Solution {
public:
    vector<int> shellSort(vector<int>& nums) {
    	int n = nums.size();
        for (int h = n / 2; h >= 1; h /= 2) {
        	for (int i = h; i < n; i ++) {
        		int base = nums[i];
        		int j = i - h;
        		while (j >= 0 && base < nums[j]) {
        			nums[j + h] = nums[j];
        			j -= h;
        		}
        	}
        	nums[j + h] = base;
        	
        }
        return nums;
    }
};

5.归并

class Solution {
public:
	// 递归式
	vector<int> mergeSortMain(vector<int>& nums) {
		mergeSort(nums, 0, nums.size() - 1);
        return nums;	
    }
    void mergeSort(vector<int>& nums, int l, int r) {
    	if (l >= r) return; 
        int mid = l + (r - l) / 2;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);
        merge(nums, l, mid, r);
        return nums;	
    }
    // 非递归式
	vector<int> mergeSort(vector<int>& nums) {
		int n = nums.size(), i = 0;
		for (int k = 1; k < n; k += k) {
			int l = 0;
			int mid = l + k - 1;
			int r = min(mid + k, n - 1);
			while (mid < n) {
				merge(nums, l, mid, r);
				l = r + 1;
				mid = l + k - 1;
				r = min(mid + k, n - 1);
			}
		}
        return nums;	
    }
    void merge(vector<int>& nums, int l, int mid, int r) {
    	int i = l, j = mid + 1, k = 0;
    	vector<int> tmp(r - l + 1);
    	while (i <= mid && j <= r) {
    		if (nums1[i] < nums2[j]) nums[k++] = nums1[i++];
    		else  nums[k++] = nums2[j++];
    	}
    	while (i <= mid) nums[k++] = nums1[i++];
    	while (j <= r) nums[k++] = nums2[j++];	
    	for (int i = 0; i < k; i++) {
    		nums[l + i] = tmp[i];
    	}
    }
};

6.快速

class Solution {
public:
	vector<int> quickSortMain(vector<int>& nums) {
		quickSort(nums, 0, nums.size() - 1);
		return nums;
    }
    void quickSort(vector<int>& nums, int l, int r) {
    	if (l >= r) return;
		int mid = partition(nums, l, r);
		quickSort(nums, l, mid - 1);
		quickSort(nums, mid + 1, r);
    }
    int partition(vector<int>& nums, int left, int right) {
    	int l = left, r = right;
    	while (l < r) {
    		while (l < r && nums[r] > nums[left]) {
    			r--;
    		}
    		while (l < r && nums[l] <= nums[left]) {
    			l++;
    		}
    		if (l < r) {
    			swap(nums[l], nums[r]);
    		}
    	}
    	swap(nums[left], nums[l]);
    	return l;
    }
};

7.堆

class Solution {
public:
	vector<int> heapSort(vector<int>& nums) {
		int n = nums.size();
		for (int i = n / 2 - 1; i >= 0; i--) {
			adjust(nums, i, n);
		}
		for (int i = n - 1; i > 0; i--) {
			swap(nums[0], nums[i]);
			adjust(nums, 0, i);
		}
		return nums;
    }
    void adjust(vector<int>& nums, int parent, int n) {
    	int child = 2 * parent + 1;
    	while (child < n) {
    		// 如果右孩子节点比左孩子大，则定位到右孩子
    		if (child + 1 < n && nums[child + 1] > nums[child]) {
    			child++;
    		}
    		if (nums[child] <= nums[parent]) {
    			return;
    		} else {
    			swap(nums[child], nums[parent]);
    			parent = child;
    			child = 2 * parent + 1;
    		}
    	}
    }
};

8.计数

class Solution {
public:
	vector<int> countSort(vector<int>& nums) {
		int n = nums.size();
		int maxNum = nums[0], minNum = nums[0];
		for (int i = 1; i < n; i++) {
			if (nums[i] > maxNum) {
				maxNum = nums[i];
			} 
			if (nums[i] < minNum) {
				minNum = nums[i];
			}
		}
		int size = maxNum - minNum + 1;
		vector<int> tmp(size);
		for (int i = 0; i < n; i++) {
			tmp[nums[i] - minNum]++;
		}
		int k = 0;
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < tmp[i]; j++) {
				nums[k++] = i + minNum;
			} 
		}
		return nums;
    }
 };

9.桶

class Solution {
public:
	vector<int> bucketSort(vector<int>& nums) {
		int n = nums.size();
		int maxNum = nums[0], minNum = nums[0];
		for (int i = 1; i < n; i++) {
			if (nums[i] > maxNum) {
				maxNum = nums[i];
			} 
			if (nums[i] < minNum) {
				minNum = nums[i];
			}
		}
		int bucketSize = 5; // 设置桶的容量
		int bucketNum = (maxNum - minNum) / bucketSize + 1; //计算桶的数量
		vector<vector<int>> buckets(bucketNum);
		for (int i = 0; i < n; i++) {
			buckets[(nums[i] - minNum) / bucketSize].push_back(nums[i]);
		}
		for (int i = 0; i < bucketNum; i++) {
			sort(buckets[i].begin(), buckets[i].end());
		}
		int k = 0;
		for (int i = 0; i < bucketNum; i++) {
			for (int j = 0; j < buckets[i].size(); j++) {
				nums[k++] = buckets[i][j];
			}
		}
		return nums;
    }
 };

10.基数

class Solution {
public:
	vector<int> bucketSort(vector<int>& nums) {
		int n = nums.size();
		int maxNum = nums[0], minNum = nums[0];
		for (int i = 1; i < n; i++) {
			if (nums[i] > maxNum) {
				maxNum = nums[i];
			} 
			if (nums[i] < minNum) {
				minNum = nums[i];
			}
		}
		int cnt = 0;
		while (maxNum > 0) {
			maxNum /= 10;
		 	cnt++;
		}
		vector<vector<int>> buckets(10);
		for (int i = 0; i < cnt; i++) {
			for (int j = 0; j < n; j++) {
				int digit = (nums[j] / pow(10, i))  % 10;
				buckets[digit].push_back(nums[j]);
			}
			int k = 0;
			for (int j = 0; j < 10; j++){
				for (int t: buckets[j]) {
					nums[k++] = t;	
				}
				buckets[j].clear();
			}
		}
		return nums;
    }
 };

题目：

1.数组中的第K个最大元素（ LeetCode 215 ）

难度： 中等
题目表述：
给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
代码（C++）：

class Solution {
public:
	//基于快排的选择方法 
    int findKthLargest(vector<int>& nums, int k) {
        return quickSelect(nums, 0, nums.size() - 1, nums.size() - k);
    }
    int quickSelect(vector<int>& nums, int l, int r, int k) {
    	if (l >= r) return nums[l];
        int mid = partition(nums, l, r);
        if(mid == k) return nums[mid];
        else if (mid > k) return quickSelect(nums, l, mid - 1, k);
        return quickSelect(nums, mid + 1, r, k);
    }
    int partition(vector<int>& nums, int left, int right) {
        int l = left, r = right;
        while (l < r) {
            while (l < r && nums[r] > nums[left]) {
                r--;
            }
            while (l < r && nums[l] <= nums[left]) {
                l++;
            }
            if (l < r) {
                swap(nums[l], nums[r]);
            }
        }
        swap(nums[left], nums[l]);
        return l;
    }
	// 基于堆排的选择方法 
    int findKthLargest(vector<int>& nums, int k) {
        int n = nums.size();
        for (int i = k / 2 - 1; i >= 0; i--) {
            adjust(nums, i, k);
        }
        for (int i = k; i < n; i++) {
            if (nums[i] > nums[0]) {
                swap(nums[i], nums[0]);
                adjust(nums, 0, k);
            }
        }
        return nums[0];
    }
    void adjust(vector<int>& nums, int parent, int n) {
        int child = parent * 2 + 1;
        while (child < n) {
            if (child + 1 < n && nums[child + 1] < nums[child]) {
                child++;
            }
            if (nums[parent] <= nums[child]) return;
            else {
                swap(nums[parent], nums[child]);
                parent = child;
                child = parent * 2 + 1;
            }
        }
    }
};

题解：
topk 问题是非常高频的考点，主要有这些方法：快速选择、建堆、排序、扫描+维护多变量、有序集合如 set、优先队列
快排：O(1) - O(N^2) 平均O(N)
堆排：O(NlogK)

2.第三大数（ LeetCode414 ）

难度： 简单
题目表述：
给你一个非空数组，返回此数组中 第三大的数 。如果不存在，则返回数组中最大的数。注意，要求返回第三大的数，是指在所有不同数字中排第三大的数。
代码（C++）：

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        set<int> s;
        for (int i = 0; i < nums.size(); i++) {
            s.insert(nums[i]);
            if (s.size() > 3) s.erase(s.begin());
        }
        return s.size() == 3 ? *s.begin() : *s.rbegin();
    }
};

题解： 有序集合
set 默认less升序，set<int, greater> 降序
sort(.begin(), .end(), greater());降序
sort(.rbegin(), .rend());降序

3.三个数的最大乘积（ LeetCode628 ）

难度： 简单
题目表述：
给你一个整型数组 nums ，在数组中找出由三个数组成的最大乘积，并输出这个乘积。
代码（C++）：

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        int max1 = INT_MIN, max2 = INT_MIN, max3 = INT_MIN;
        int min1 = INT_MAX, min2 = INT_MAX;
        for (int x: nums) {
            if (x > max1) {
                max3 = max2;
                max2 = max1;
                max1 = x;
            } else if (x > max2) {
                max3 = max2;
                max2 = x;
            } else if (x > max3) 
                max3 = x;
            if (x < min1) {
                min2 = min1;
                min1 = x;
            } else if (x < min2) {
                min2 = x;
            } 
        }
        return max(min1 * min2 * max1, max1 * max2 * max3);
    }
};

题解： 线性扫描

小结

topk 问题： 快速选择、建堆、排序、扫描+维护多变量、有序集合如 set、优先队列

其他C++知识点：
set< int > 默认less升序，set<int, greater< T >> 降序
sort(.begin(), .end(), greater< T > ()); 降序
sort(.rbegin(), .rend()); 降序

priority_queue< T > 默认是大根堆，priority_queue<T, vector< T >, greater< T >>小根堆
自定义priority_queue的cmp示例：decltype(cmp) “ > 小根堆，< 大根堆 ”

auto cmp = [](const pair<string, int>& a, const pair<string, int>& b) {
	return a.second == b.second ? a.first < b.first : a.second > b.second;
};
priority_queue<pair<string, int>, vector<pair<string, int>>, decltype(cmp)> que(cmp);

参考链接

https://leetcode.cn/circle/article/zLSmiB/

123冲鸭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode刷题笔记——排序算法篇
qq_42898642的博客
02-16 1258
本文给大家介绍了面试中常考的关于排序问题的算法题，本文重点介绍了计数排序、快速排序、堆排序（重点）、插入排序、归并排序（重点）、桶排序、还有自定义排序规则
LeetCode高频题刷题笔记（十三）回溯算法
qq_29355253的博客
04-11 108
15：组合、组合总和 III、电话号码的字母组合、组合总和、组合总和 II、分割回文串、复原 IP 地址、子集、子集 II、递增子序列、全排列、全排列 II、重新安排行程、N皇后、解数独
LeetCode高频题刷题笔记（五）哈希表
qq_29355253的博客
03-28 395
13：模拟行走机器人、串联所有单词的子串、数组的度、子域名访问计数、字母异位词分组、有效的字母异位词、查找共用字符、两个数组的交集、快乐数、三数之和、四数之和、四数相加 II、赎金信
LeetCode高频题刷题笔记（十）数学题
qq_29355253的博客
04-07 77
4：Pow(x, n)、字符串相乘、字符串转换整数 (atoi)、整数反转
lrucacheleetcode-awesome-algorithm:代码模板、脑图、Top100高频LeetCode题-极简实用的算法和数据
06-29
lru缓存leetcode 很棒的算法和数据结构 专注于帮助以更高效、更有条理的方式掌握算法和数据结构： 具有可视化和示例代码的基础数据结构，使用不同的编程语言。 带综合笔记的前 100 名 LeetCode 问题（最高频 100 题...
2024年互联网面试算法常见100题精析.pdf
01-05
为此，有一本专门的算法图解笔记，收录了105道高频面试算法题目，以漫画图解的形式呈现，适合算法初学者和中级读者。这本教程注重基础知识的串联，力求让每个读者都能掌握每道题目的解题思路。其特色在于每道题都有...
leetcode中国-DataStructure:数据结构与算法的学习basepython/c++
06-29
目前主要分为算法基础、Leetcode高频题和剑指offer三大块。 目前我主力在更新算法基础，剑指offer会在算法基础更新完结之后启动更新。 By the way，感谢Y神。 （还是有很多没有更，不知道什么时候会补更，算法和数据...
华为OD机考小结+算法编程试题一遍过
03-08
- Labuladong的刷题三件套：包括《算法秘籍》和《刷题笔记》的PDF，以及一个刷题插件。 4. **核心知识点**： - 基础知识：字符串操作、数组、链表、队列和栈，排序、迭代、递归、二分查找。 - 进阶知识：树、堆...
leetcode答案-JianZhi_Offer:JianZhi_Offer
06-30
leetcode 答案 面试算法笔记 版本：0.0.1 作者：张天亮 邮箱： 2020年03月16日 个人整理 刷题 其他资源 ...算法导论python实现 ...面试高频算法题总结，个人博客 : 《剑指Offer》题目汇总&常考题总结(Python实现)
leetcode hot100 （面试复习用）
大厂小码农的博客
07-20 529
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]// 继续向左查找} else {// 查找目标值在数组中的结束位置// 继续向右查找} else {
【LeetCode】分隔链表
qq_26521261的博客
07-20 236
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 241
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
1. LeetCode-数组和字符串
weixin_43149506的博客
07-18 908
数组和字符串介绍以及相关例题
LeetCode --- 2138. Divide a String Into Groups of Size k 解题报告
杨鑫newlife的专栏
07-16 3466
A string can be partitioned into groups of size using the following procedure:Note that the partition is done so that after removing the character from the last group (if it exists) and concatenating all the groups in order, the resultant string should
每日一题，力扣leetcode Hot100之283. 移动零
u013373155的博客
07-19 211
首先，两个指针都指向同一个位置，i=j=0，如果移动指针i的位置不为0则进行交换，固定指针+1，如果为0的话，固定指针不变，移动指针往后面移一直找。这样的话固定指针就会指在0的位置，相当于移动指针遇到非0就和0进行交换。对于当前数组进行调整，不使用额外空间，那么既用双指针。
Leetcode热题100 Day2
KGthe3的博客
07-19 102
但是即使这样我在写的时候还是花了很多时间，一个是边界条件的处理（尤其是连续有相同值的处理）以及我发现了leetcode的编译器和本地的编译器不一样：本地没有进行越界检查，但是leetcode是开启了的。首先需要对原先的区间进行排序，排序的原则是先按照左端从小到大，左端相同则看右端。这样的话，用两个指针表示当前的已合并区间的左端和右端，不断判断这个右端是否大于下一个区间的左端，如果大于，则合并。窗口的特性是窗口内所有字母的出现次数，因为是异位值，所以只要出现次数相同即可，并不需要考虑出现的顺序。
力扣88.合并两个有序数组（Java）
2301_80369371的博客
07-16 170
一般两个有序数组合并，都是从后往前赋值，因为两个数组中的最大值相比较出来的最大值，就是合并后的最大值，所以可以直接丢在最后面，然后如此类推，直到某一个数组被比较完，如果是第一个数组，则只需要将第二个数组剩下的直接赋值过去即可；如果是第二个数组，则不用管了，因为前面放的就是第一个数组的值。同时注意特殊情况，如果第一个数组的有效值为0个，合并后就是第二个数组，则只需要将第二个数组复制给第一个数组即可；如果第二个数组的有效值为0个，则不需要进行任何操作，合并后就是第一个数组。
Leetcode 2520. 统计能整除数字的位数
最新发布
GQ_666的博客
07-20 90
121 可以被 1 整除，但无法被 2 整除。由于 1 出现两次，所以返回 2。好久好久没写算法了，今天开始写，先从最简单的开始。希望自己可以坚持下去。1248 可以被它每一位上的数字整除，因此答案是 4。7 被自己整除，因此答案是 1。
LeetCode与LintCode算法刷题笔记
"这是一份关于算法和数据结构的刷题笔记，主要涵盖LeetCode和Lintcode上的题目，包括Python和Java语言的实现。笔记详细梳理了基础数据结构、排序算法、基本算法策略等多个方面的知识，并对每个主题进行了深入的细分...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值