栈和队列

最新推荐文章于 2022-10-02 23:06:09 发布
最新推荐文章于 2022-10-02 23:06:09 发布
阅读量150 收藏
点赞数
分类专栏： leetcode 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miracleon/article/details/107410854
版权

文章目录

用栈实现队列

leetcode232

栈的顺序为后进先出，而队列的顺序为先进先出。使用两个栈实现队列，一个元素需要经过两个栈才能出队列，在经过第一个栈时元素顺序被反转，经过第二个栈时再次被反转，此时就是先进先出顺序。

class MyQueue {
    
    private Stack<Integer> in;
    private Stack<Integer> out;

    /** Initialize your data structure here. */
    public MyQueue() {
        in = new Stack<>();
        out = new Stack<>();
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
        in.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        inToOut();
        return out.pop();
    }
    
    /** Get the front element. */
    public int peek() {
        inToOut();
        return out.peek();
    }
    
    public void inToOut(){
        if(out.isEmpty()){
            while(!in.isEmpty()){
                out.push(in.pop());
            }
        }
    }
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return in.isEmpty() && out.isEmpty();
    }
}

用队列实现栈

leetcode225
在将一个元素 x 插入队列时，为了维护原来的后进先出顺序，需要让 x 插入队列首部。而队列的默认插入顺序是队列尾部，因此在将 x 插入队列尾部之后，需要让除了 x 之外的所有元素出队列，再入队列。
例如：
[2,1]->[1,2]
[3,1,2]->[1,2,3]

class MyStack {

    Queue<Integer> queue;
    /** Initialize your data structure here. */
    public MyStack() {
        queue = new LinkedList<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        queue.add(x);
        int size = queue.size();
        while(size-- > 1){
            queue.add(queue.remove());
        }
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue.poll();
    }
    
    /** Get the top element. */
    public int top() {
        return queue.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue.size() == 0;
    }
}

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.queue = []

    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        self.queue.append(x)
        for i in range(len(self.queue)):
            self.queue.append(self.queue.pop(0))

    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        return self.queue.pop()

    def top(self) -> int:
        """
        Get the top element.
        """
        return self.queue[-1]

    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        return not self.queue

最小值栈

leetcode155
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

  • push(x) —— 将元素 x 推入栈中。
  • pop() —— 删除栈顶的元素。
  • top() —— 获取栈顶元素。
  • getMin() —— 检索栈中的最小元素。

法一：直接底层构造MinStack

class MinStack {
    private Node head;

    private class Node{
        int val;
        int min;
        Node next;

        public Node(int val, int min) {
            this.val = val;
            this.min = min;
            next = null;
        }
    }
    
    public void push(int x) {
        if (head == null) {
            head = new Node(x, x);
        }else {
            Node node = new Node(x, Math.min(x, head.min));
            node.next = head;
            head = node;
        }
    }
    
    public void pop() {
        head = head.next;
    }
    
    public int top() {
        return head.val;
    }
    
    public int getMin() {
        return head.min;
    }
}

法二：双栈实现，一个存储值，一个存储最小值

class MinStack {

    private Stack<Integer> dataStack;
    private Stack<Integer> minStack;
    private int min;

    public MinStack(){
        dataStack = new Stack<>();
        minStack = new Stack<>();
        min = Integer.MAX_VALUE;
    }
    public void push(int x) {
        dataStack.push(x);
        min = Math.min(x, min);
        minStack.push(min);
    }
    
    public void pop() {
        dataStack.pop();
        minStack.pop();
        min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
    }
    
    public int top() {
        return dataStack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

法三：用一个栈，但更新最小值时把原最小值再入栈一次

class MinStack {
    int min = Integer.MAX_VALUE;
    Stack<Integer> stack = new Stack<Integer>();
    public void push(int x) {
        //当前值更小
        if(x <= min){   
            //将之前的最小值保存
            stack.push(min);
            //更新最小值
            min=x;
        }
        stack.push(x);
    }

    public void pop() {
        //如果弹出的值是最小值，那么将下一个元素更新为最小值
        //这里进入if判断语句，已经先执行一次pop()
        if(stack.pop() == min) {
            min=stack.pop();
        }
    }

    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return min;
    }
}

法四：压入差值
同样是用一个 min 变量保存最小值。只不过栈里边我们不去保存原来的值，而是去存储入栈的值和最小值的差值。然后得到之前的最小值的话，我们就可以通过 min 值和栈顶元素得到，举个例子。

入栈 3，存入 3 - 3 = 0
|   |   min = 3
|   |     
|_0_|    
stack   

入栈 5，存入 5 - 3 = 2
|   |   min = 3
| 2 |     
|_0_|    
stack  

入栈 2，因为出现了更小的数，所以我们会存入一个负数，这里很关键
也就是存入  2 - 3 = -1, 并且更新 min = 2 
对于之前的 min 值 3, 我们只需要用更新后的 min - 栈顶元素 (-1) 就可以得到    
| -1|   min = 2
| 5 |     
|_3_|    
stack  

入栈 6，存入  6 - 2 = 4
| 4 |   min = 2
| -1| 
| 5 |     
|_3_|    
stack  

出栈，返回的值就是栈顶元素 4 加上 min，就是 6
|   |   min = 2
| -1| 
| 5 |     
|_3_|    
stack  

出栈，此时栈顶元素是负数，说明之前对 min 值进行了更新。
入栈元素 - min = 栈顶元素，入栈元素其实就是当前的 min 值 2
所以更新前的 min 就等于入栈元素 2 - 栈顶元素(-1) = 3
|   | min = 3
| 5 |     
|_3_|    
stack     

public class MinStack {
    long min;
	Stack<Long> stack;

	public MinStack(){
        stack=new Stack<>();
    }

	public void push(int x) {
		if (stack.isEmpty()) {
			min = x;
			stack.push(x - min);
		} else {
			stack.push(x - min);
			if (x < min){
				min = x; // 更新最小值
			}
				
		}
	}

	public void pop() {
		if (stack.isEmpty())
			return;
        //由于我们保存的是差值，所以可能造成溢出，所以我们用了数据范围更大的 long 类型。
		long pop = stack.pop();
		
		//弹出的是负值，要更新 min
		if (pop < 0) {
			min = min - pop;
		}

	}
	//？？？个人认为只要返回栈顶元素即可，min更新会在pop时，但提交错误
	public int top() {
		long top = stack.peek();
		//负数的话，出栈的值保存在 min 中
		if (top < 0) {
			return (int) (min);
        //出栈元素加上最小值即可
		} else {
			return (int) (top + min);
		}
	}

	public int getMin() {
		return (int) min;
	}
}

用栈实现括号匹配

leetcode20

示例 1:

输入: "()"
输出: true

示例 2:

输入: "()[]{}"
输出: true

示例 3:

输入: "(]"
输出: false

示例 4:

输入: "([)]"
输出: false

示例 5:

输入: "{[]}"
输出: true
  • 法一
class Solution {
    public boolean isValid(String s) {
    //字符长度必须是偶数，空字符串也为true
    if ((s.length() & 1)== 1){
            return false;
        }
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            if (c == '(' || c == '{' || c == '['){
                stack.push(c);
            }else {
            //栈空，说明表达式无效，没有与此时右括号匹配的左括号
                if (stack.isEmpty()){
                    return false;
                }
                if (c == ')' && stack.peek() == '('){
                    stack.pop();
                }
                else if (c == '}' && stack.peek() == '{'){
                    stack.pop();
                }
                else if (c == ']' && stack.peek() == '['){
                    stack.pop();
                }else {
                	return false;
                }
            }
        }
        //栈不为空，false
        return stack.isEmpty();
    }
}
  • 法二：官方解法，用hashmap
class Solution {
    private Map<Character,Character> map;
    public Solution(){
        map = new HashMap<>();
        this.map.put(')','(');        
        this.map.put(']','[');
        this.map.put('}','{');

    }
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        if((s.length() & 1) == 1){
            return false;
        }
        for(int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            if(map.containsKey(c)){
                char top = stack.isEmpty() ? '#' : stack.peek();
                if(top == map.get(c)){
                    stack.pop();
                }else{
                    return false;
                }
            }else{
                stack.push(c);
            }
        }
        return stack.isEmpty();
    }
}
  • 法三：最简(cyc大佬博客这里)
public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '{' || c == '[') {
            stack.push(c);
        } else {
            if (stack.isEmpty()) {
                return false;
            }
            char cStack = stack.pop();
            boolean b1 = c == ')' && cStack != '(';
            boolean b2 = c == ']' && cStack != '[';
            boolean b3 = c == '}' && cStack != '{';
            //b1、b2、b3有一个true
            if (b1 || b2 || b3) {
                return false;
            }
        }
    }
    return stack.isEmpty();
}

数组中元素与下一个比它大元素之间的距离

leetcode739每日温度

  • 法一：用栈保存数组元素
    在遍历数组时用栈把数组中的数存起来，如果当前遍历的数比栈顶元素来的大，说明栈顶元素的下一个比它大的数就是当前元素。

从左往右遍历

class Solution {
    public int[] dailyTemperatures(int[] T) {
        int len = T.length;
        int[] dist = new int[len];
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < len; i++) {
            while (!stack.isEmpty() && T[i] > T[stack.peek()]) {
                int preIndex = stack.pop();
                dist[preIndex] = i - preIndex;
            }
            //stack本身没有add()方法，但是继承的类vector有add方法,同样vector的父类和实现接口List同样有add()方法。
            stack.add(i);
        }
        return dist;
    }
}

从右往左

class Solution {
    public int[] dailyTemperatures(int[] T) {
        int[] dist = new int[T.length];
        Stack<Integer> s = new Stack<>();
        for(int i = T.length-1; i >= 0; i--){
            while(!s.empty() && T[i] >= T[s.peek()]){
                s.pop();//将不大于当前元素的剔除
            }
            dist[i] = s.empty() ? 0 : (s.peek() - i);
            s.push(i);
        }
        return dist;
    }
}
  • 法二：从数组右边遍历，减少重复次数
class Solution {
    public int[] dailyTemperatures(int[] T) {
        int N = T.length;
        int[] dist = new int[N];
        Arrays.fill(dist,0);
        for(int i = N - 2; i >= 0; i--){
         // j+= dist[j]是利用已经有的结果进行跳跃
            for(int j = i + 1; j < N; j += dist[j]){
                if(T[j] > T[i]){
                    dist[i] = j - i;
                    break;
                }else if(dist[j] == 0){//遇到0表示后面不会有更大的值，那当然当前值就应该也为0
                    dist[i] = 0;
                    break;//不加的话会超出时间限制
                }
            }
        }
        return dist;
    }
}

循环数组中比当前元素大的下一个元素

leetcode503

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int N = nums.length;
        int[] result = new int[N];
        Arrays.fill(result,-1);
        Stack<Integer> s = new Stack<>();
        for(int i = 0; i < 2*N; i++){
            while(!s.isEmpty() && nums[i%N] > nums[s.peek()]){
                int pre = s.pop();
                result[pre] = nums[i%N];
            }
            if(i < N){
                s.push(i);
            }
        }
        return result;
    }
}
回首往昔少年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
队列类模板简易版
计算机视觉爱好者
07-15 626
队列类模板简易版
用栈实现队列（C++）
weixin_42817333的博客
05-25 983
题目：请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）。 leetcode链接 实现 MyQueue 类： void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean empty() 如果队列为空，返回 true ；否则，返回 false 示例 1： 输入： [“MyQueue”, “push”, “push”, “peek”, “pop”
队列（queue）的模板类及其成员函数的实现
skyinmoon的专栏
06-06 6988
队列（queue）是先进先出的数据结构，存储方式可以是数组也可以是链表。如果用数组存储，一般采用循环队列的方式。 所以需记住几个关键点： 队头指针进1：front = (front+1)%maxsize 队尾指针进1：rear = (rear+1)%maxsize 判断队空：front = rear 判断队满：front = (rear+1)%maxsize，这里，队满的时候队尾和队头之
数据结构（二）栈和队列（模板实现）
最新发布
qq_64246637的博客
10-02 671
允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。后置条件：如果删除成功，队头减少了一个元素 GetQueue。队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。输出：如果队列为空，返回1，否则，返回0。输出：如果删除成功，返回被删元素值。后置条件：如果插入成功，队尾增加了一个元素。输出：若队列不空，返回队头元素。前置条件：队列不存在。空队列：不含任何数据元素的队列。前置条件：队列已存在。前置条件：队列已存在。前置条件：队列已存在。前置条件：队列已存在。
队列类模板
yohongbo的专栏
09-23 732
#ifndef QUEUE_CLASS#define QUEUE_CLASS#include #include using namespace std;const int MaxQSize = 50; //队列元素最大个数//类的声明template class Queue{    private:        int front, rear, count; //队头指针、队尾指针、元素
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
zhanheduilie.rar_栈和队列
09-24
栈和队列是计算机科学中基础且重要的数据结构，它们在程序设计中有着广泛的应用。在本资料"zhanheduilie.ppt"中，详细讲述了这两种数据结构的原理、特性以及实际应用。 栈（Stack）是一种后进先出（LIFO, Last In ...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
栈和队列的基本操作
01-02
"栈和队列的基本操作" 栈和队列是计算机科学中两个基本的数据结构，它们的基本操作包括进栈、出栈、进队、出队等。栈是一种后进先出的数据结构，即最后一个入栈的元素将是第一个出栈的元素。队列是一种先进先出的...
数据结构栈和队列
04-08
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
栈和队列PPT
05-23
栈和队列PPT课件，想要了解栈和队列的同学，可以下载一下。
c++ 类模板 用栈实现队列
Li_zhonglei的博客
08-05 864
c++语言可以利用STL库中定义的栈类实现队列的操作。 包括入队列、出队列操作。 下面就是用两个栈实现队列的上述操作。其中涉及到类模板的知识，不清楚的可以去其它地方进行查询。 #include #include using namespace std; template class CQueue { public: //CQueue(void); //~CQueue(v
栈与队列-顺序队列与链队列类模板的实现（数据结构基础 第3周）
NodYoung
06-30 824
这里Queue写的跟在STL中的使用方法基本上是一致的，经过了简单的测试。需要注意的是下面测试程序中并没有制定顺序列表（即数组）的大小，类模板中默认为10，当数据量超过指定大小时自动开辟一个更大的数组。 运行测试程序的结果： 源码 //Queue.h#pragma template <class T> class Queue { public: void clear();
栈和队列基础与实现
"本资源是关于课堂练习，主要涉及栈和队列这两种数据结构，特别是循环队列的入队和出队算法。同时，提供了链式队列的定义以及栈...通过链式队列和顺序栈的示例，学生可以深入理解这两种数据结构的工作原理和实现细节。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值