算法训练Day10 栈与队列part01

最新推荐文章于 2024-07-09 16:46:46 发布

晴天了吗！

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量909

点赞数 22

文章标签： java 开发语言算法数据结构

本文链接：https://blog.csdn.net/weixin_74356916/article/details/136046205

版权

栈与队列理论基础

栈（Stack）是一种后进先出（LIFO，Last In First Out）的数据结构，而队列（Queue）则是一种先进先出（FIFO，First In First Out）的数据结构。

栈提供push 和 pop 等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)。不像是set 或者map 提供迭代器iterator来遍历所有元素。

栈的内部结构，栈的底层实现可以是vector，deque，list 都是可以的，主要就是数组和链表的底层实现

我们常用的SGI STL，如果没有指定底层实现的话，默认是以deque为缺省情况下栈的底层结构。

deque是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。

SGI STL中队列底层实现缺省情况下一样使用deque实现的。

基础语法

栈

push(x) -- 元素 x 入栈
pop() -- 移除并返回栈顶元素
top() -- 获取栈顶元素,并不移除元素
empty() -- 返回栈是否为空

队列

Boolean offer(x) -- 添加元素到队列

poll() -- 移除并返回队列头部的元素

peek() -- 返回元素

isEmpty() -- 返回队列是否为空

size() -- 返回队列中的元素数量

用栈实现队列

队列的语法：

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。

示例:

MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

代码运行如下图：

通过两个栈的相互配合，成功模拟了队列的行为

class MyQueue {

    Stack<Integer> stackIn;
    Stack<Integer> stackOut;

    /** Initialize your data structure here. */
    public MyQueue() {
        stackIn = new Stack<>(); // 负责进栈
        stackOut = new Stack<>(); // 负责出栈
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
        stackIn.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {    
        dumpstackIn();
        return stackOut.pop();
    }
    
    /** Get the front element. */
    public int peek() {
        dumpstackIn();
        return stackOut.peek();
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return stackIn.isEmpty() && stackOut.isEmpty();
    }

    // 如果stackOut为空，那么将stackIn中的元素全部放到stackOut中
    private void dumpstackIn(){
        if (!stackOut.isEmpty()) return; 
        while (!stackIn.isEmpty()){
                stackOut.push(stackIn.pop());
        }
    }
}

代码解释：

构造函数 MyQueue()：初始化两个栈，stackIn 和 stackOut。stackIn 负责处理入队操作，即将新元素放入队列的尾部；stackOut 负责处理出队和查看队首元素的操作。
push(int x) 方法：将元素 x 压入 stackIn 栈。这个操作对应于将元素加入队列的尾部。
pop() 方法：返回并移除队列前端的元素。这里首先调用 dumpstackIn() 方法确保 stackOut 中有元素（如果 stackOut 为空，则将 stackIn 中所有元素转移到 stackOut 中，这样做是为了保持先进先出的顺序）。然后从 stackOut 中弹出栈顶元素，这个元素对应于队列前端的元素。
peek() 方法：返回队列前端的元素，但不移除它。这个方法的实现逻辑与 pop() 方法相似，也是首先确保 stackOut 中有元素，然后返回 stackOut 栈顶元素。
empty() 方法：检查队列是否为空。只有当两个栈 stackIn 和 stackOut 都为空时，队列才为空。
dumpstackIn() 私有方法：这个方法用于将 stackIn 中的所有元素转移到 stackOut 中，但仅当 stackOut 为空时才执行此操作。这一步骤是关键，因为它确保了队列的先进先出顺序。通过将 stackIn 的元素倒入 stackOut，我们反转了元素的顺序，使得最先进入 stackIn 的元素（也就是最早加入队列的元素）位于 stackOut 的栈顶，从而可以作为下一个出队的元素。

用队列实现栈

①使用两个Queue (队列)

将元素 x 放入辅助队列 queue2。然后，我们通过将 queue1 中的所有元素依次放入 queue2 来确保新加入的元素 x 在栈顶。最后，我们通过交换 queue1 和 queue2 的引用，将所有的元素都放到 queue1 中，同时让 queue2 变为空。

这样，每次执行 push 操作时，元素都会被放入 queue1 的队首

class MyStack {

    Queue<Integer> queue1; // 和栈中保持一样元素的队列
    Queue<Integer> queue2; // 辅助队列

    /** Initialize your data structure here. */
    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        queue2.offer(x); // 先放在辅助队列中，后将剩下的元素加入尾后
        while (!queue1.isEmpty()){  //实现先进先出的顺序结构
            queue2.offer(queue1.poll());
        }
        Queue<Integer> queueTemp;
        queueTemp = queue1;
        queue1 = queue2;
        queue2 = queueTemp; // 最后交换queue1和queue2，将元素都放到queue1中
    }
    
    /** 移除并返回元素 */
    public int pop() {
        return queue1.poll(); // 因为queue1中的元素和栈中的保持一致，所以这个和下面两个的操作只看queue1即可
    }
    
    /** Get the top element. */
    public int top() {
        return queue1.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue1.isEmpty();
    }
}

上述代码push方法的替换:

/** 在加入元素时先将q1中的元素依次出栈压入q2，
然后将新加入的元素压入q1，再将q2中的元素依次出栈压入q1 */
    public void push(int x) {
        while (q1.size() > 0) {
            q2.add(q1.poll());
        }
        q1.add(x);
        while (q2.size() > 0) {
            q1.add(q2.poll());
        }
    }

②使用两个Deque(双向队列)

使用Deque时,可直接对首尾操作 : top方法使用peekLast

首先获取 que1 的大小，并将其减一，然后通过遍历将 que1 中除了最后一个元素之外的所有元素依次移动到 que2 中。接着，弹出 que1 中的最后一个元素作为结果返回。

随后，将 que2 的引用赋值给 que1，这样就确保了 que1 和 que2 指向相同的队列。最后，为了避免直接操作 que2 对 que1 产生影响，重新为 que2 分配一个新的空间。

class MyStack {
    // Deque 接口继承了 Queue 接口
    // 所以 Queue 中的 add、poll、peek等效于 Deque 中的 addLast、pollFirst、peekFirst
    Deque<Integer> que1; // 和栈中保持一样元素的队列
    Deque<Integer> que2; // 辅助队列
    /** Initialize your data structure here. */
    public MyStack() {
        que1 = new ArrayDeque<>();
        que2 = new ArrayDeque<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        que1.addLast(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        int size = que1.size();
        size--;
        // 将 que1 导入 que2 ，但留下最后一个值
        while (size-- > 0) {
            que2.addLast(que1.peekFirst());
            que1.pollFirst();
        }

        int res = que1.pollFirst();
        // 将 que2 对象的引用赋给了 que1 ，此时 que1，que2 指向同一个队列
        que1 = que2;
        // 如果直接操作 que2，que1 也会受到影响，所以为 que2 分配一个新的空间
        que2 = new ArrayDeque<>();
        return res;
    }
    
    /** Get the top element. */
    public int top() {
        return que1.peekLast();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return que1.isEmpty();
    }
}

③使用一个 Deque

利用size()直接将首元素调到尾部

class MyStack {
    // Deque 接口继承了 Queue 接口
    // 所以 Queue 中的 add、poll、peek等效于 Deque 中的 addLast、pollFirst、peekFirst
    Deque<Integer> que1;
    /** Initialize your data structure here. */
    public MyStack() {
        que1 = new ArrayDeque<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        que1.addLast(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        int size = que1.size();
        size--;
        // 将 que1 导入 que2 ，但留下最后一个值
        while (size-- > 0) {
            que1.addLast(que1.peekFirst());
            que1.pollFirst();
        }

        int res = que1.pollFirst();
        return res;
    }
    
    /** Get the top element. */
    public int top() {
        return que1.peekLast();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return que1.isEmpty();
    }
}

优化pop方法

 public int pop() {
       
        int res = que1.pollLast();
        
        return res;
    }

④ 使用一个 Queue

原理同③

class MyStack {

    Queue<Integer> queue;

    public MyStack() {
        queue = new LinkedList<>();
    }

    //每 offer 一个数（A）进来，都重新排列，把这个数（A）放到队列的队首
    public void push(int x) {
        queue.offer(x);
        int size = queue.size();
        //移动除了 A 的其它数
        while (size-- > 1)
            queue.offer(queue.poll());
    }

    public int pop() {
        return queue.poll();
    }

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

    public boolean empty() {
        return queue.isEmpty();
    }
}

晴天了吗！

关注

22
点赞
踩
16

收藏

觉得还不错? 一键收藏
1
评论
算法训练Day10 栈与队列part01

栈（Stack）是一种后进先出（LIFO，Last In First Out）的数据结构，而队列（Queue）则是一种先进先出（FIFO，First In First Out）的数据结构。栈提供push 和 pop 等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)。不像是set 或者map 提供迭代器iterator来遍历所有元素。栈的内部结构，栈的底层实现可以是vector，deque，list 都是可以的，主要就是数组和链表的底层实现。
复制链接

扫一扫