【LeetCode刷题日记】队列类题目常见题型_leetcode 队列 题

最新推荐文章于 2024-05-12 21:46:11 发布
最新推荐文章于 2024-05-12 21:46:11 发布
阅读量1.8k 收藏 28
点赞数 51
分类专栏： 2024年程序员学习 文章标签： leetcode 网络 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84264741/article/details/137790675
版权

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Golang全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
img
img
img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注go）
img

正文

struct tagListNode* next;
int val;
} ListNode;

typedef struct {
ListNode* top;
} MyStack;

MyStack* myStackCreate() {
MyStack* stk = calloc(1, sizeof(MyStack));
return stk;
}

void myStackPush(MyStack* obj, int x) {
ListNode* node = malloc(sizeof(ListNode));
node->val = x;
node->next = obj->top;
obj->top = node;
}

int myStackPop(MyStack* obj) {
ListNode* node = obj->top;
int val = node->val;
obj->top = node->next;
free(node);

return val;
}

int myStackTop(MyStack* obj) {
return obj->top->val;
}

bool myStackEmpty(MyStack* obj) {
return (obj->top == NULL);
}

void myStackFree(MyStack* obj) {
while (obj->top != NULL) {
ListNode* node = obj->top;
obj->top = obj->top->next;
free(node);
}
free(obj);
}

class MyStack {
public:
queue q;

/** Initialize your data structure here. */
MyStack() {

}

/** Push element x onto stack. */
void push(int x) {
int n = q.size();
q.push(x);
for (int i = 0; i < n; i++) {
q.push(q.front());
q.pop();
}
}

/** Removes the element on top of the stack and returns that element. */
int pop() {
int r = q.front();
q.pop();
return r;
}

/** Get the top element. */
int top() {
int r = q.front();
return r;
}

/** Returns whether the stack is empty. */
bool empty() {
return q.empty();
}
};

剑指 Offer 09. 用两个栈实现队列

在这里插入图片描述
在这里插入图片描述

class CQueue {
stack stack1,stack2;
public:
CQueue() {
while (!stack1.empty()) {
stack1.pop();
}
while (!stack2.empty()) {
stack2.pop();
}
}

void appendTail(int value) {
stack1.push(value);
}

int deleteHead() {
// 如果第二个栈为空
if (stack2.empty()) {
while (!stack1.empty()) {
stack2.push(stack1.top());
stack1.pop();
}
}
if (stack2.empty()) {
return -1;
} else {
int deleteItem = stack2.top();
stack2.pop();
return deleteItem;
}
}
};

239. 滑动窗口最大值

在这里插入图片描述
在这里插入图片描述

void swap(int** a, int** b) {
int* tmp = *a;
*a = *b, *b = tmp;
}

int cmp(int* a, int* b) {
return a[0] == b[0] ? a[1] - b[1] : a[0] - b[0];
}

struct Heap {
int** heap;
int size;
int capacity;
};

void init(struct Heap* obj, int capacity) {
obj->size = 0;
obj->heap = NULL;
obj->capacity = capacity;
obj->heap = malloc(sizeof(int*) * (obj->capacity + 1));
for (int i = 1; i <= obj->capacity; i++) {
obj->heap[i] = malloc(sizeof(int) * 2);
}
}

void setFree(struct Heap* obj) {
for (int i = 1; i <= obj->capacity; i++) {
free(obj->heap[i]);
}
free(obj->heap);
free(obj);
}

void push(struct Heap* obj, int num0, int num1) {
int sub1 = ++(obj->size), sub2 = sub1 >> 1;
(obj->heap[sub1])[0] = num0, (obj->heap[sub1])[1] = num1;
while (sub2 > 0 && cmp(obj->heap[sub2], obj->heap[sub1]) < 0) {
swap(&(obj->heap[sub1]), &(obj->heap[sub2]));
sub1 = sub2, sub2 = sub1 >> 1;
}
}

void pop(struct Heap* obj) {
int sub = 1;
swap(&(obj->heap[sub]), &(obj->heap[(obj->size)–]));
while (sub <= obj->size) {
int sub1 = sub << 1, sub2 = sub << 1 | 1;
int maxSub = sub;
if (sub1 <= obj->size && cmp(obj->heap[maxSub], obj->heap[sub1]) < 0) {
maxSub = sub1;
}
if (sub2 <= obj->size && cmp(obj->heap[maxSub], obj->heap[sub2]) < 0) {
maxSub = sub2;
}
if (sub == maxSub) {
break;
}
swap(&(obj->heap[sub]), &(obj->heap[maxSub]));
sub = maxSub;
}
}

int* top(struct Heap* obj) {
return obj->heap[1];
}

int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize) {
struct Heap* q = malloc(sizeof(struct Heap));
init(q, numsSize);
for (int i = 0; i < k; i++) {
push(q, nums[i], i);
}
int* ans = malloc(sizeof(int) * (numsSize - k + 1));
*returnSize = 0;
ans[(*returnSize)++] = top(q)[0];

for (int i = k; i < numsSize; ++i) {
push(q, nums[i], i);
while (top(q)[1] <= i - k) {
pop(q);
}
ans[(*returnSize)++] = top(q)[0];
}
setFree(q);
return ans;
}

class Solution {
public:
vector maxSlidingWindow(vector& nums, int k) {
int n = nums.size();
priority_queue<pair<int, int>> q;
for (int i = 0; i < k; ++i) {
q.emplace(nums[i], i);
}
vector ans = {q.top().first};
for (int i = k; i < n; ++i) {
q.emplace(nums[i], i);
while (q.top().second <= i - k) {
q.pop();
}
ans.push_back(q.top().first);
}
return ans;
}
};

https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210906132327420.png

int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize) {
int q[numsSize];
int left = 0, right = 0;
for (int i = 0; i < k; ++i) {
while (left < right && nums[i] >= nums[q[right - 1]]) {
right–;
}
q[right++] = i;
}
*returnSize = 0;
int* ans = malloc(sizeof(int) * (numsSize - k + 1));
ans[(*returnSize)++] = nums[q[left]];
for (int i = k; i < numsSize; ++i) {
while (left < right && nums[i] >= nums[q[right - 1]]) {
right–;
}
q[right++] = i;
while (q[left] <= i - k) {
left++;
}
ans[(*returnSize)++] = nums[q[left]];
}
return ans;
}

class Solution {
public:
vector maxSlidingWindow(vector& nums, int k) {
int n = nums.size();
deque q;
for (int i = 0; i < k; ++i) {
while (!q.empty() && nums[i] >= nums[q.back()]) {
q.pop_back();
}
q.push_back(i);
}

vector ans = {nums[q.front()]};
for (int i = k; i < n; ++i) {
while (!q.empty() && nums[i] >= nums[q.back()]) {
q.pop_back();
}
q.push_back(i);
while (q.front() <= i - k) {
q.pop_front();
}
ans.push_back(nums[q.front()]);
}
return ans;
}
};

622. 设计循环队列

https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210906132746631.png

在这里插入图片描述
https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210906132844093.png
https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210906132911406.png
在这里插入图片描述

面试题 03.04. 化栈为队

在这里插入图片描述

https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210906133302016.png

typedef struct {
int* stk;
int stkSize;
int stkCapacity;
} Stack;

Stack* stackCreate(int cpacity) {
Stack* ret = malloc(sizeof(Stack));
ret->stk = malloc(sizeof(int) * cpacity);
ret->stkSize = 0;
ret->stkCapacity = cpacity;
return ret;
}

void stackPush(Stack* obj, int x) {
obj->stk[obj->stkSize++] = x;
}

void stackPop(Stack* obj) {
obj->stkSize–;
}

int stackTop(Stack* obj) {
return obj->stk[obj->stkSize - 1];
}

bool stackEmpty(Stack* obj) {
return obj->stkSize == 0;
}

void stackFree(Stack* obj) {
free(obj->stk);
}

typedef struct {
Stack* inStack;
Stack* outStack;
} MyQueue;

MyQueue* myQueueCreate() {
MyQueue* ret = malloc(sizeof(MyQueue));
ret->inStack = stackCreate(100);
ret->outStack = stackCreate(100);
return ret;
}

void in2out(MyQueue* obj) {
while (!stackEmpty(obj->inStack)) {
stackPush(obj->outStack, stackTop(obj->inStack));
stackPop(obj->inStack);
}
}

void myQueuePush(MyQueue* obj, int x) {
stackPush(obj->inStack, x);
}

int myQueuePop(MyQueue* obj) {
if (stackEmpty(obj->outStack)) {
in2out(obj);
}
int x = stackTop(obj->outStack);
stackPop(obj->outStack);
return x;
}

int myQueuePeek(MyQueue* obj) {
if (stackEmpty(obj->outStack)) {
in2out(obj);
}
return stackTop(obj->outStack);
}

bool myQueueEmpty(MyQueue* obj) {
return stackEmpty(obj->inStack) && stackEmpty(obj->outStack);
}

void myQueueFree(MyQueue* obj) {
stackFree(obj->inStack);
stackFree(obj->outStack);
}

class MyQueue {
private:
stack inStack, outStack;

void in2out() {
while (!inStack.empty()) {
outStack.push(inStack.top());
inStack.pop();
}
}

public:
MyQueue() {}

void push(int x) {
inStack.push(x);
}

int pop() {
if (outStack.empty()) {
in2out();
}
int x = outStack.top();
outStack.pop();
return x;
}

int peek() {
if (outStack.empty()) {
in2out();
}
return outStack.top();
}

bool empty() {
return inStack.empty() && outStack.empty();
}
};

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）
img

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
{
in2out();
}
int x = outStack.top();
outStack.pop();
return x;
}

int peek() {
if (outStack.empty()) {
in2out();
}
return outStack.top();
}

bool empty() {
return inStack.empty() && outStack.empty();
}
};

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）
[外链图片转存中…(img-j9rHXJzd-1713176357830)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84264741
关注
  • 51
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode刷题班题库
02-15
总的来说，《leetcode刷题班题库》是一份全面而深入的学习资料，它不仅提供了大量的编程题目，更关键的是，它提供了详细的解题过程，帮助学习者逐步建立解决问题的能力。通过系统地学习和实践，你将能够在算法和数据...
LeetCode刷题笔记.rar
07-05
在LeetCode中，常见的数据结构包括数组、链表、栈、队列、哈希表、树（二叉树、平衡树如AVL和红黑树等）、图、堆等。每个数据结构都有其独特的特性，例如，数组提供随机访问但插入和删除操作效率低，而链表则相反；...
LeetCode高频题刷题笔记（四）队列
qq_29355253的博客
03-24 170
6：滑动窗口最大值、最小覆盖子串、无重复字符的最长子串、删除子数组的最大得分、找到字符串中所有字母异位词、前 K 个高频元素
leetcode栈和队列
weixin_47414034的博客
06-30 478
1.栈和队列常见方法(1)栈： （2）队列： 双端队列：（1）队列只能在队尾添加元素，在队头删除元素，而双端队列在队头队尾都可以进行添加和删除操作（2）双端队列Deque的常见方法：（在队列的add，peek，remove方法基础上进行改造） 2.用两个栈实现队列：力扣（剑指offer09）把栈和队列都想象成一个黑箱子将1，2，3依次输入到这个黑箱子，如果这个黑箱子是栈，就依次返回3，2，1
【数据结构】— 『队列』的实现以及LeetCode队列练习题
qq_63938813的博客
09-10 704
作者：甘宸しぐれ 文章简介：数据结构初阶中队列的实现，以及LeetCode，如何用栈实现队列，如何用队列实现栈OJ题详解。
Leetcode经典题目之用队列实现栈
最新发布
LiU11e的博客
05-12 839
经典leetcode题目之使用队列实现栈
Leetcode练习之队列
qq_40142361的博客
09-11 250
和栈相反，队列是只允许在⼀端进⾏插⼊，在另⼀端进⾏删除的线性表。因此队列(Queue)是⼀种先进先出(FIFO - First In First Out)的数据结构，通常情况下，我们称队列中插⼊元素的⼀端为尾部，删除元素的⼀端为头部。 队列也是⼀种逻辑结构，底层同样可以⽤数组实现，也可以⽤链表实现，不同实现有不同的取舍。如果⽤数组实现，那么⼊队或者出队的时间复杂度⼀定有且仅有⼀个是O(N)O(N)O(N)的，其中 NNN 为队列的⻓度。⽽使⽤链表实现则可以在 O(1)O(1)O(1)的时间完成任何合法的队列
LeetCode_java_leetcode_刷题_
09-30
本资料包聚焦于Java语言，整理了150多道LeetCode上的热门问题，是Java开发者进行刷题训练的理想资源。 LeetCode中的题目涵盖了数据结构、算法、设计模式等多个方面，每道题目都分为Easy、Medium、Hard三个难度级别...
leetcode分类-leetcode:leetcode刷题（中等难度分类）
06-30
在编程领域，LeetCode 是一个非常知名的在线平台，它提供了丰富的算法题目，旨在帮助开发者提升编程技能、理解和解决实际问题。本篇将聚焦于LeetCode中的中等难度题目，通过深入探讨这些题目，我们可以深化对数据...
LeetCode 刷题笔记 with Java.zip
11-23
接着是《LeetCode 刷题笔记 with Java 51-100.pdf》，这个阶段的题目难度逐渐提升，涉及了二叉树、图、堆、队列等复杂的数据结构。例如，“Merge Intervals”（合并区间）要求我们合并时间重叠的事件区间，这需要...
LeetCode栈队列集锦
如风暖阳的博客
07-10 458
LeetCode栈队列集锦
队列及其leetcode的一些练习
dksyqph的博客
10-25 236
队列及其leetcode的一些练习
Leetcode 栈队列篇
weixin_45223092的博客
12-12 161
leetcode 栈队列篇
LeetCode 刷题之队列
hj1993的博客
02-15 442
队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出的（）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。与栈一样，队列可以通过顺序表或链表来实现。
Leetcode队列
qq_42354640的博客
10-14 410
LeetCode队列入门，广度优先搜索初级题解
LeetCode算法之队列
huangshanchun的专栏
05-02 705
1 什么是队列 队列是一种特殊的线性表，限定只能在线性表的一端进行插入（队尾），而在另一端进行删除操作（对头），特点是先进先出（FIFO）。 双端队列是两端都可以进行插入和移除操作的队列。 Deque<Integer> queue=new ArrayDeque<>(); //添加一个元素 queue.addFirst(1); queue.addLast(1); System.out.println(queue.p
leetcode——队列总结
Dedication_的博客
08-14 345
一、实现代码 #include <iostream> #define MAXSIZE 100 using namespace std; struct Queue { int *data; int front; int rear; Queue() { data = new int[MAXSIZE]; front = 0; rear = 0; } //压入——rear+1 int push(int elem) { if ((rear + 1) % MAXSIZE == fron
LeetCode刷题队列&栈经典例题
yoyoyoyoy6的博客
11-20 407
菜鸡的LeetCode刷题笔记思路
leetcode刷题，C++刷题技巧
11-08
leetcode 刷题技巧，题型有数组、动态规划、数学、字符串、树、哈希表、深度优先搜索、二分查找、贪心算法、广度优先搜索、双指针

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值