LeetCode刷题记录（三）
剑指 Offer 30. 包含min函数的栈
利用辅助桟s2来存放最小值，如果有比s2更小的则让更小的进s2，当原s1中最小值出栈时，判断如果同s2值相当，代表需要更新最小值，则s2栈顶出栈
class MinStack {
public:
stack<int>s1;
stack<int>s2;
/** initialize your data structure here. */
MinStack() {
s2.push(INT_MAX);
}
void push(int x) {
s1.push(x);
if(x<=s2.top()){
s2.push(x);
}
}
void pop() {
if(s1.top()==s2.top()) s2.pop(); //s1出栈元素同s2栈顶保存的最小值相等
s1.pop();
}
int top() {
return s1.top();
}
int min() {
return s2.top(); //s2的栈顶始终保存最小值
}
};
面试题32 - I. 从上到下打印二叉树
二叉树的层次遍历 3，9,20,15,7依次入队
class Solution {
public:
vector<int> levelOrder(TreeNode* root) {
vector<int>v;
if(root == NULL) return v;
queue<TreeNode*>q; //初始化队列
q.push(root); //根结点入队
while(!q.empty()){
TreeNode * node = q.front(); //队首出队
q.pop();
v.push_back(node->val);
if(node->left) q.push(node->left); //该结点的左孩子入队
if(node->right) q.push(node->right); //右孩子入队
}
return v;
}
};
剑指 Offer 32 - II. 从上到下打印二叉树 II
和上一题差不多一模一样，就是多了一个分层输出，怎么分层：根结点入队，队列size()为1，根结点左右孩子入队，队列size()为2，假设为满二叉树，则再向下，size()为4.......一直这样，每层有几个结点就i=q.size()，再i--把每个结点输出
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
// 层次遍历问题
vector<vector<int>> v;
if(root==NULL){
return v;
}
queue<TreeNode *>q;
q.push(root);
while(!q.empty()){ //队列非空时
vector<int>temp;
for(int i=q.size();i>0;i--) //关键的分层的办法
{
TreeNode * node = q.front();
q.pop();
temp.push_back(node->val);
if(node->left) q.push(node->left);
if(node->right) q.push(node->right);
}
v.push_back(temp); //保存这一层的结果
}
return v;
}
};
剑指 Offer 32 - III. 从上到下打印二叉树 III![image-20220306113134809]
方法一：和上一题一样，但是用一个数字来记录层数，然后奇数层正常，偶数层反转一下就可以了
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
// 层次遍历问题
vector<vector<int>> v;
if(root==NULL){
return v;
}
queue<TreeNode *>q;
q.push(root);
int deep = 1;
while(!q.empty()){//队列非空时
vector<int>temp;
for(int i=q.size();i>0;i--)//关键的分层的办法
{
TreeNode * node = q.front();
q.pop();
temp.push_back(node->val);
if(node->left) q.push(node->left);
if(node->right) q.push(node->right);
}
if(deep%2 ==0){
reverse(temp.begin(),temp.end());
}
v.push_back(temp);
deep++;
}
return v;
}
};
还可以用双端队列
// 使用双端队列 （树的偶层: 尾入(先左子结点再右子结点)头出; 树的奇层: 头入(先右子结点再左子结点)尾出）
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
if (root == nullptr) {
return {};
}
vector<vector<int>> vec;
deque<TreeNode*>dqe;
int level = 0;
dqe.push_back(root); // root结点在第0层(偶层)，所以从队列尾入
while (!dqe.empty()) {
int level_nodes = dqe.size();
vec.push_back({});
if (level % 2 != 0) { // 奇层: 从队列头入(先右子结点再左子结点)，队列尾出
while (level_nodes) {
TreeNode* p_node = dqe.back();
if (p_node->right != nullptr) dqe.push_front(p_node->right);
if (p_node->left != nullptr) dqe.push_front(p_node->left);
vec[level].push_back(p_node->val);
dqe.pop_back();
--level_nodes;
}
++level;
}
else { // 偶层: 从队列尾入(先左子结点再右子结点)，队列头出
while (level_nodes) {
TreeNode* p_node = dqe.front();
if (p_node->left != nullptr) dqe.push_back(p_node->left);
if (p_node->right != nullptr) dqe.push_back(p_node->right);
vec[level].push_back(p_node->val);
dqe.pop_front();
--level_nodes;
}
++level;
}
}
return vec;
}
};
88. 合并两个有序数组
就是说给两个非递减的数组，然后让你把第一个数组的前n位和第二个数组的前m位合并到一个数组1中（数组1的长度为M+N）
逆序双指针（双指针的思想常用）
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int i = nums1.size() - 1;
m--; //下标从0开始，所以先减1
n--;
while (n >= 0) {
while (m >= 0 && nums1[m] > nums2[n]) {
nums1[i--]=nums1[m--];
}
nums1[i--]=nums2[n--];
}
}
剑指 Offer 39. 数组中出现次数超过一半的数字
这题是408出现过的原题，最好想的是做统计，排序，但这题用的是投票法
因为一定出现众数，每次出现众数就+1，不是就-1，最后一定大于0
class Solution {
public:
int majorityElement(vector<int>& nums) {
int res = nums[0]; //先设nums[0]为众数
int count = 1;
for(int i = 1;i<nums.size();i++){
if(nums[i]==res){ //值相等++
count++;
}else{ //值不等进一步判断
if(count==1){ //仅剩1次，那么将众数更新
res = nums[i];
}else{
count--; //出现次数--
}
}
}
return res;
}
};
大佬的写法：本题具有特殊性，即不用判断是否为众数，最好还是可以加上一个判断
class Solution {
public:
int majorityElement(vector<int>& nums) {
int x = 0, votes = 0, count = 0;
for(int num : nums){
if(votes == 0) x = num;
votes += num == x ? 1 : -1;
}
// 验证 x 是否为众数
for(int num : nums)
if(num == x) count++;
return count > nums.size() / 2 ? x : 0; // 当无众数时返回 0
}
};
剑指 Offer 40. 最小的k个数
4种解法秒杀TopK（快排/堆/二叉搜索树/计数排序）❤️ - 最小的k个数 - 力扣（LeetCode） (leetcode-cn.com)
剑指 Offer 40. 最小的 k 个数（基于快速排序的数组划分，清晰图解） - 最小的k个数 - 力扣（LeetCode） (leetcode-cn.com)
1.快速选择算法
优化了的快速排序，因为只需要找出最小的k个，并不关心他们的顺序
同快排一样使用频率很高
class Solution {
public:
vector<int> getLeastNumbers(vector<int>& arr, int k) {
if(k>=arr.size()) return arr;
return quick_select(arr, k, 0, arr.size() - 1);
}
vector<int>quick_select(vector<int>&arr,int k,int low,int high){
int i = low;
int j = high;
int pivot = arr[i];//选定枢轴
while(i<j){
while(i<j && arr[j]>=pivot) --j;
arr[i] = arr[j] ;
while(i<j && arr[i]<=pivot) ++i;
arr[j] = arr[i];
}
arr[i] = pivot; //枢轴归位
// 再判断是否需要继续，如果i>k，代表范围大了，减小范围
//若果i<k代表我们的范围小了，需要再次划分
if (i > k) return quick_select(arr, k, low, i - 1);
if (i < k) return quick_select(arr, k, i + 1, high);
vector<int> res;
res.assign(arr.begin(), arr.begin() + k); //返回前K个
return res;
}
};
414. 第三大的数
方法一：使用集合(默认排序)，且仅保存3个数
class Solution {
public:
int thirdMax(vector<int> &nums) {
set<int> s;
for (int num : nums) {
s.insert(num);
if (s.size() > 3) { //超过3个元素就删除其中最小的
s.erase(s.begin());
}
}
return s.size() == 3 ? *s.begin() : *s.rbegin(); //不足3个数就返回最大的(例二的情况)
}
};
解法二：用三个指针，仅用一轮扫描就可以找到
class Solution {
public:
int thirdMax(vector<int> &nums) {
int *a = nullptr, *b = nullptr, *c = nullptr;
for (int &num : nums) {
if (a == nullptr || num > *a) {
c = b;
b = a;
a = #
} else if (*a > num && (b == nullptr || num > *b)) {
c = b;
b = #
} else if (b != nullptr && *b > num && (c == nullptr || num > *c)) {
c = #
}
}
return c == nullptr ? *a : *c;
}
};
215. 数组中的第K个最大元素(这个条件又比上面的苛刻一些了)
解法一：还是直接快排
解法二：快速选择
class Solution {
public:
int quickSelect(vector<int>& a, int l, int r, int index) {
int q = randomPartition(a, l, r);
if (q == index) {
return a[q];
} else {
return q < index ? quickSelect(a, q + 1, r, index) : quickSelect(a, l, q - 1, index);
}
}
inline int randomPartition(vector<int>& a, int l, int r) {
int i = rand() % (r - l + 1) + l;//引入随机化 快排的时间复杂度取决于划分
swap(a[i], a[r]);
return partition(a, l, r);
}
inline int partition(vector<int>& a, int l, int r) {//划分
int x = a[r], i = l - 1;
for (int j = l; j < r; ++j) {
if (a[j] <= x) {
swap(a[++i], a[j]);
}
}
swap(a[i + 1], a[r]);
return i + 1;
}
int findKthLargest(vector<int>& nums, int k) {
srand(time(0));
return quickSelect(nums, 0, nums.size() - 1, nums.size() - k);
}
};
解法三：利用大根堆
class Solution {
public:
void maxHeapify(vector<int>& a, int i, int heapSize) {
int l = i * 2 + 1, r = i * 2 + 2, largest = i;
if (l < heapSize && a[l] > a[largest]) {
largest = l;
}
if (r < heapSize && a[r] > a[largest]) {
largest = r;
}
if (largest != i) {
swap(a[i], a[largest]);
maxHeapify(a, largest, heapSize);
}
}
void buildMaxHeap(vector<int>& a, int heapSize) { //建堆操作
for (int i = heapSize / 2; i >= 0; --i) {
maxHeapify(a, i, heapSize);
}
}
int findKthLargest(vector<int>& nums, int k) {
int heapSize = nums.size();
buildMaxHeap(nums, heapSize);
for (int i = nums.size() - 1; i >= nums.size() - k + 1; --i) {
swap(nums[0], nums[i]);
--heapSize;
maxHeapify(nums, 0, heapSize);
}
return nums[0];
}
};
keep real ,stay hungry ,and dream future
