栈、队列、优先队列、双端队列

于 2020-05-31 12:00:07 发布
阅读量347 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41375318/article/details/106453513
版权

视频教程：B站、网易云课堂、腾讯课堂
代码地址：Gitee、Github
存储地址：
百度云-提取码：
Google云

有效的括号：description
国内站

java版

/*
思路：
// 1. 暴力：不断replace匹配的括号 -> ""  时间复杂度：O(n^2)

// 2. 栈

*/


class Solution {
    private static final Map<Character,Character> map = new HashMap<Character,Character>(){{
        put('{','}'); put('[',']'); put('(',')'); put('?','?');
    }};
    public boolean isValid(String s) {
        if(s.length() > 0 && !map.containsKey(s.charAt(0))) return false;
        LinkedList<Character> stack = new LinkedList<Character>() {{ add('?'); }};
        for(Character c : s.toCharArray()){
            if(map.containsKey(c)) stack.addLast(c);
            else if(map.get(stack.removeLast()) != c) return false;
        }
        return stack.size() == 1;
    }
}

/*
评价：
优点：
缺点：
*/

python版：

'''
思路：

'''


class Solution:
    def isValid(self, s: str) -> bool:
        dic = {'{': '}',  '[': ']', '(': ')', '?': '?'}
        stack = ['?']
        for c in s:
            if c in dic: stack.append(c)
            elif dic[stack.pop()] != c: return False 
        return len(stack) == 1


'''
评价：
  优点：
  缺点：
'''

'''
思路：

'''
class Solution:
    def isValid(self, s: str) -> bool:
        dic = {')':'(',']':'[','}':'{'}
        stack = []
        for i in s:
            if stack and i in dic:
                if stack[-1] == dic[i]: stack.pop()
                else: return False
            else: stack.append(i)
            
        return not stack

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

最小栈：min-stack/

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

class MinStack {
    int min = Integer.MAX_VALUE;
    Stack<Integer> stack = new Stack<Integer>();
    public void push(int x) {
        // only push the old minimum value when the current 
        // minimum value changes after pushing the new value x
        if(x <= min){          
            stack.push(min);
            min=x;
        }
        stack.push(x);
    }

    public void pop() {
        // if pop operation could result in the changing of the current minimum value, 
        // pop twice and change the current minimum value to the last minimum value.
        if(stack.pop() == min) min=stack.pop();
    }

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

    public int getMin() {
        return min;
    }
}



/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

柱状图中最大的矩形：largest-rectangle-in-histogram/

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

class Solution {
    public static int largestRectangleArea(int[] height) {
        if (height == null || height.length == 0) {
            return 0;
        }
        int[] lessFromLeft = new int[height.length]; // idx of the first bar the left that is lower than current
        int[] lessFromRight = new int[height.length]; // idx of the first bar the right that is lower than current
        lessFromRight[height.length - 1] = height.length;
        lessFromLeft[0] = -1;

        for (int i = 1; i < height.length; i++) {
            int p = i - 1;

            while (p >= 0 && height[p] >= height[i]) {
                p = lessFromLeft[p];
            }
            lessFromLeft[i] = p;
        }

        for (int i = height.length - 2; i >= 0; i--) {
            int p = i + 1;

            while (p < height.length && height[p] >= height[i]) {
                p = lessFromRight[p];
            }
            lessFromRight[i] = p;
        }

        int maxArea = 0;
        for (int i = 0; i < height.length; i++) {
            maxArea = Math.max(maxArea, height[i] * (lessFromRight[i] - lessFromLeft[i] - 1));
        }

        return maxArea;
    }
}

/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

滑动窗口最大值：sliding-window-maximum/

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

We scan the array from 0 to n-1, keep “promising” elements in the deque. The algorithm is amortized O(n) as each element is put and polled once.

At each i, we keep “promising” elements, which are potentially max number in window [i-(k-1),i] or any subsequent window. This means

If an element in the deque and it is out of i-(k-1), we discard them. We just need to poll from the head, as we are using a deque and elements are ordered as the sequence in the array

Now only those elements within [i-(k-1),i] are in the deque. We then discard elements smaller than a[i] from the tail. This is because if a[x] <a[i] and x<i, then a[x] has no chance to be the “max” in [i-(k-1),i], or any other subsequent window: a[i] would always be a better candidate.

As a result elements in the deque are ordered in both sequence in array and their value. At each step the head of the deque is the max element in [i-(k-1),i]
java版

/*
思路：

*/

class Solution {
    public int[] maxSlidingWindow(int[] a, int k) {		
            if (a == null || k <= 0) {
                return new int[0];
            }
            int n = a.length;
            int[] r = new int[n-k+1];
            int ri = 0;
            // store index
            Deque<Integer> q = new ArrayDeque<>();
            for (int i = 0; i < a.length; i++) {
                // remove numbers out of range k
                while (!q.isEmpty() && q.peek() < i - k + 1) {
                    q.poll();
                }
                // remove smaller numbers in k range as they are useless
                while (!q.isEmpty() && a[q.peekLast()] < a[i]) {
                    q.pollLast();
                }
                // q contains index... r contains content
                q.offer(i);
                if (i >= k - 1) {
                    r[ri++] = a[q.peek()];
                }
            }
            return r;
        }
}


/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

设计循环双端队列：design-circular-deque/

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

class MyCircularDeque {
    int size;
    int k;
    DoubleListNode head;
    DoubleListNode tail;
    /** Initialize your data structure here. Set the size of the deque to be k. */
    public MyCircularDeque(int k) {
        head = new DoubleListNode(-1);
        tail = new DoubleListNode(-1);
        head.pre = tail;
        tail.next = head;
        this.k = k;
        this.size = 0;
    }
    
    /** Adds an item at the front of Deque. Return true if the operation is successful. */
    public boolean insertFront(int value) {
        if (size == k)
            return false;
        DoubleListNode node = new DoubleListNode(value);
        node.next = head;
        node.pre = head.pre;
        head.pre.next = node;
        head.pre = node;
        size++;
        return true;
    }
    
    /** Adds an item at the rear of Deque. Return true if the operation is successful. */
    public boolean insertLast(int value) {
        if (size == k)
            return false;
        DoubleListNode node = new DoubleListNode(value);
        node.next = tail.next;
        tail.next.pre = node;
        tail.next = node;
        node.pre = tail;
        size++;
        return true;
    }
    
    /** Deletes an item from the front of Deque. Return true if the operation is successful. */
    public boolean deleteFront() {
        if (size == 0)
            return false;
        head.pre.pre.next = head;
        head.pre = head.pre.pre;
        size--;
        return true;
    }
    
    /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
    public boolean deleteLast() {
        if (size == 0)
            return false;
        tail.next.next.pre = tail;
        tail.next = tail.next.next;
        size--;
        return true;
    }
    
    /** Get the front item from the deque. */
    public int getFront() {
        return head.pre.val;
    }
    
    /** Get the last item from the deque. */
    public int getRear() {
        return tail.next.val;
    }
    
    /** Checks whether the circular deque is empty or not. */
    public boolean isEmpty() {
        return size == 0;
    }
    
    /** Checks whether the circular deque is full or not. */
    public boolean isFull() {
        return size == k;
    }
}

class DoubleListNode {
    DoubleListNode pre;
    DoubleListNode next;
    int val;
    public DoubleListNode(int val) {
        this.val = val;
    }
}


/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

接雨水:trapping-rain-water/

国内站

java版

/*
思路：

*/




/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

国外站

java版

/*
思路：

*/

class Solution {
    public int trap(int[] A){
        int a=0;
        int b=A.length-1;
        int max=0;
        int leftmax=0;
        int rightmax=0;
        while(a<=b){
            leftmax=Math.max(leftmax,A[a]);
            rightmax=Math.max(rightmax,A[b]);
            if(leftmax<rightmax){
                max+=(leftmax-A[a]);       // leftmax is smaller than rightmax, so the (leftmax-A[a]) water can be stored
                a++;
            }
            else{
                max+=(rightmax-A[b]);
                b--;
            }
        }
        return max;
    }
}


/*
评价：
优点：
缺点：
*/

python版：



'''
思路：

'''

'''
评价：
  优点：
  缺点：
'''

c++版：

/*
思路：

*/


/*
评价：
优点：
缺点：
*/

一 栈和队列的实现与特性

在这里插入图片描述

在这里插入图片描述

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

在这里插入图片描述

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

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

二 实战题目解析：有效的括号、最小栈等问题

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

*Major*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
优先队列
快速乘与快速幂
03-07 191
//对于基础类型 默认是大顶堆 priority_queue<int> a; //升序队列 priority_queue <int,vector<int>,greater<int> > q; //降序队列 priority_queue <int,vector<int>,less<int> >q; //greate...
双端队列
qwerLoL123456的博客
10-04 995
1. 双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。 双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。 双端队列可以在队列任意一端入队和出队。 2. 操作 Deque() 创建一个空的双端队列 add_front(item) 从队头加入一个item元素 add_rear(item) 从队尾加入一个item元素 ...
双端队列题解
weixin_42856344的博客
07-18 803
双端队列题解 Description Sherry现在碰到了一个棘手的问题，有Ｎ个整数需要排序。 Sherry手头能用的工具就是若干个双端队列。 她需要依次处理这N个数，对于每个数，Sherry能做以下两件事： 1．新建一个双端队列，并将当前数作为这个队列中的唯一的数； 2．将当前数放入已有的队列的头之前或者尾之后。 对所有的数处理完成之后，Sherry将这些队列排序后就可以得到一个非降的序列。 ...
栈，队列和双端队列
weixin_30355437的博客
03-11 99
栈：后进先出 队列：先进先出 双端队列：两边都可以插入和删除 1. 匹配分隔符（应用的原理：栈） 1 def is_matched(expr): 2 """return true if delimiters are properly match;False otherwise""" 3 lefty = '({[' 4 rghty = ')...
数据结构笔记：双端队列
01-21
双端队列（deque，double-ended queue），是一种具有队列和栈的性质的数据结构。 双端队列中每一端，都可以进行存入和取出，去其中一段，都像一个栈一样。 存取也只限定在两端，不能在中间 双端队列的实现 通过...
Python实现双端队列
12-22
Python实现双端队列 关于双端队列的介绍，请参考：https://blog.csdn.net/weixin_43790276/article/details/104033337 双端队列的数据存储结构可以是顺序表，也可以是链表，本篇文章使用 Python 来分别实现顺序双端...
设计循环双端队列
12-21
设计循环双端队列（Circular Double-ended Queue，简称CircDeq）是一种特殊的线性数据结构，它允许在两端进行插入和删除操作。在实际应用中，如在数据缓存、队列操作优化等方面有着广泛用途。本题要求实现一个循环...
duilie.rar_双端队列
09-19
这种特性使得双端队列在许多算法和程序设计中非常实用，比如作为栈的替代，或者在需要快速访问两端元素的场景下。接下来我们将深入探讨循环双端队列的实现及其基本操作。 首先，让我们了解循环双端队列的基本概念。...
关于优先级队列STL
weixin_30700977的博客
08-28 79
STL之priority_queue【转】 STL之priority_queue【转】 STL之优先队列 原本以为priority_queue很简单，才知道原来懂的只是最简单的形式。 头文件：#include<queue> 优先队列，也就是原来我们学过的堆，按照自己定义的优先级出队时。默认情况下底层是以Vector实现的heap。 既然是队列，也就只有入队、出队、...
Deque（双向队列）
baidu_34884208的博客
02-15 2026
Deque（双向队列） Deque（双向队列）是一种优化了的、对序列两端元素进行添加和删除操作的基本序列容器。它允许较为快速地随机访问，但它不像vector把所有的对象保存在一块连续的内存块，而是采用多个连续的存储块，并且在一个映射结构中保存对这些块及其顺序的跟踪。向deque两端添加或删除元素的开销很小。它不需要重新分配空间，所以向末端增加元素比vector更有效。 实际上，deque是对vec...
优先队列和双端队列的异同
最新发布
06-08
优先队列和双端队列是两种非常不同的数据结构，它们的主要区别在于它们的目的和操作方式。 - 目的： 优先队列是一种特殊的队列，它可以根据元素的优先级来确定元素的顺序。优先队列的目的是在队列中快速找到具有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值