精华内容
下载资源
问答
  • 用栈实现队列

    2019-04-19 16:18:09
    用栈实现队列 package com.test; import java.util.Stack; public class Main { //用栈实现队列 private static Stack<Integer> in = ...

                                                                        用栈实现队列

    package com.test;
    
    import java.util.Stack;
    
    public class Main {
    
        //用栈实现队列
        private static Stack<Integer> in = new Stack<>();
        private static Stack<Integer> out = new Stack<>();
    
        public static void main(String[] args) {
            int[] a = {1, 2, 3, 4};
            for (int i = 0; i < a.length; i++) {
                in.push(a[i]);
            }
            while(!in.empty()){
                System.out.println(in.peek());
                out.push(in.peek());
                in.pop();
            }
        }
    }

     

    展开全文
  • 用栈实现队列 用队列实现栈

    千次阅读 2019-04-15 18:25:06
    烦死了 还不如给学妹做图标开心...用栈实现队列 两个栈实现 图(1):元素“abcd”压入stack1中,stack2为空; 图(2):stack1中的元素pop进stack2中,pop一下stack2中的元素,和队列一样了 图(3):可能有些人很...

    前言:你说栈和队列全部都用数组实现多好 非得找麻烦 到头来底层还是数组
    上课弄了两节课 终于弄懂了这个栈和队列的相互实现
    烦死了 还不如给学妹做图标开心
    在这里插入图片描述
    19.04.17更新:自闭ing…开心有个什么用?图标被直接弃用!!!连个修改的机会都没有!!!简直要比阿里的主管面给我的打击还要大!疯狂自闭中!!!气炸了气炸了,以后再也不做图标了!这将是我的封笔之作

    栈和队列

    数据结构入门-栈和队列

    用栈实现队列

    两个栈实现


    图(1):元素“abcd”压入stack1中,stack2为空;

    图(2):stack1中的元素pop进stack2中,pop一下stack2中的元素,和队列一样了

    图(3):可能有些人很疑惑,就像图3,当stack2只pop了一个元素a时,satck1中可能还会插入元素e,这时如果将stack1中的元素e插入stack2中,在a之后出栈的元素就是e了,显然,这样想是不对的,我们必须规定当stack2中的元素pop完之后,也就是satck2为空时,再插入stack1中的元素

    Java实现

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

    用队列实现栈

    所有元素进入q1,因为我们的目的是栈,也就是最先出c,而队是从队头开始出,所有先把ab出q1并入q2,此时目标c跑到了队头,出q1。此时q1已经为空,下一个要出的是b,把a从q2出队并进q1,此时目标b在q2队头,出队
    在这里插入图片描述

    public class MyStack {
        private Queue<Integer> queue1;
        private 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) {
            if (queue1.peek() != null){
                while (queue1.peek() != null) {
                    queue2.offer(queue1.poll());
                }
                queue1.offer(x);
                while (queue2.peek() != null) {
                    queue1.offer(queue2.poll());
                }
            }else{
                queue1.offer(x);
            }
        }
    
        /**
         * Removes the element on top of the stack and returns that element.
         */
        public int pop() {
            if (queue1.peek() == null){
                return 0;
            }
            return queue1.poll();
        }
    
        /**
         * Get the top element.
         */
        public int top() {
            if (queue1.peek() == null){
                return 0;
            }
            return queue1.peek();
        }
    
        /**
         * Returns whether the stack is empty.
         */
        public boolean empty() {
            return queue1.peek() == null ? true : false;
        }
    }
    

    以上记录的是用两个栈实现队列和用两个队列实现栈,看到还有分别用一个实现的高级解法,日后遇到在更新
    或许以后就会知道为什么不直接用数组实现的原因了吧

    展开全文
  • 如何用栈实现队列以及用队列实现栈 用栈实现队列 package com.dataStructure.array; import java.util.Stack; /** * 使用栈模拟队列 */ public class stackToQueue { private Stack<Integer> pushStack;...

    如何用栈实现队列以及用队列实现栈

    在这里插入图片描述

    用栈实现队列

    package com.dataStructure.array;
    
    import java.util.Stack;
    
    /**
     * 使用栈模拟队列
     */
    public class stackToQueue {
        private Stack<Integer> pushStack;
        private Stack<Integer> popStack;
        public stackToQueue(){
            pushStack=new Stack<Integer>();
            popStack=new Stack<Integer>();
        }
        public void push(Integer obj) {
            pushStack.push(obj);
        }
        public Integer pop(){
            if(pushStack.empty()&&popStack.empty())
                throw new RuntimeException("Queue is empty!");
            else if(popStack.empty()){
                while(!pushStack.empty())
                popStack.push(pushStack.pop());
            }
            return popStack.pop();
        }
        public Integer peek(){
            if(pushStack.empty()&&popStack.empty())
                throw new RuntimeException("Queue is empty!");
            else if(popStack.empty()){
                while(!pushStack.empty())
                    popStack.push(pushStack.pop());
            }
            return popStack.peek();
        }
        public static void main(String[] args){
            stackToQueue stackToQueue=new stackToQueue();
            for(int i=0;i<15;i++)
                stackToQueue.push(i);
            System.out.println(stackToQueue.pop());
            System.out.println(stackToQueue.peek());
        }
    }
    
    

    用队列实现栈

    package com.dataStructure.array;
    
    import java.util.LinkedList;
    import java.util.Queue;
    
    //使用队列实现栈的效果
    public class queueToStack {
        private Queue<Integer> dataQueue;
        private Queue<Integer> helpQueue;
        public queueToStack(){
            dataQueue=new LinkedList<Integer>();
            helpQueue=new LinkedList<Integer>();
        }
        //模拟入栈效果
        public void push(Integer obj){
            dataQueue.add(obj);
        }
        //模拟出栈效果
        public Integer pop(){
            helpQueue.clear();
            if(dataQueue.size()==0){
                throw new RuntimeException("Stack is empty!");
            }
            //除了最后一个全部出栈
            while(dataQueue.size()!=1)
            {
                helpQueue.add(dataQueue.poll());
            }
            int res= dataQueue.poll();
            swap();
            return res;
        }
        //模拟获取栈顶元素
        public Integer peek(){
            helpQueue.clear();
            if(dataQueue.size()==0){
                throw new RuntimeException("Stack is empty!");
            }
            //除了最后一个全部出栈
            while(dataQueue.size()!=1)
            {
                helpQueue.add(dataQueue.poll());
            }
            int res= dataQueue.poll();
            helpQueue.add(res);
            swap();
            return res;
        }
        //获取栈顶元素
        public void swap(){
            Queue<Integer> tempQueue=helpQueue;
            helpQueue=dataQueue;
            dataQueue=tempQueue;
        }
        public static void main(String[] args){
            queueToStack queueToStack=new queueToStack();
            for(int i=0;i<15;i++)
                queueToStack.push(i);
            queueToStack.pop();
            System.out.println(queueToStack.peek());
        }
    }
    
    
    展开全文
  • 用栈实现队列(Leetcode 232) Leetcode 225:用队列实现栈 准备两个queue:q1, q2 每次将元素先放入q2,然后将q1元素全部放入q2,再将q1和q2交换,这样能够保证每次最后进入的元素都在队列q1的最前端,实现栈...

    本文包含的Leetcode题目

    1. 用队列实现栈(Leetcode 225)
    2. 用栈实现队列(Leetcode 232)

    Leetcode 225:用队列实现栈

    在这里插入图片描述

    准备两个queue:q1, q2
    每次将元素先放入q2,然后将q1元素全部放入q2,再将q1和q2交换,这样能够保证每次最后进入的元素都在队列q1的最前端,实现栈逻辑。

    class MyStack {
    public:
        queue<int> queue1;
        queue<int> queue2;
    
        /** Initialize your data structure here. */
        MyStack() {
    
        }
    
        /** Push element x onto stack. */
        void push(int x) {
            queue2.push(x);
            while (!queue1.empty()) {
                queue2.push(queue1.front());
                queue1.pop();
            }
            swap(queue1, queue2);
        }
        
        /** Removes the element on top of the stack and returns that element. */
        int pop() {
            int r = queue1.front();
            queue1.pop();
            return r;
        }
        
        /** Get the top element. */
        int top() {
            int r = queue1.front();
            return r;
        }
        
        /** Returns whether the stack is empty. */
        bool empty() {
            return queue1.empty();
        }
    };
    

    Leetcode 232:用栈实现队列

    在这里插入图片描述
    准备两个栈s1,s2 s1用来存放数据,s2用来颠倒数据并弹出

    class MyQueue {
    public:
        stack<int> s1;
        stack<int> s2;
        /** Initialize your data structure here. */
        MyQueue() {
    
        }
        
        /** Push element x to the back of queue. */
        void push(int x) {
            s1.push(x);
        }
        
        /** Removes the element from in front of queue and returns that element. */
        int pop() {
            if (s2.empty()) {
                while (!s1.empty()) {
                    s2.push(s1.top());
                    s1.pop();
                }
            }
            int res = s2.top();
            s2.pop();
            return res;
        }
        
        /** Get the front element. */
        int peek() {
            int res = this->pop();    //peek操作可以直接调用pop() 
            s2.push(res); 
            return res;
        }
        
        /** Returns whether the queue is empty. */
        bool empty() {
            return s1.empty() && s2.empty();
        }
    };
    
    /**
     * Your MyQueue object will be instantiated and called as such:
     * MyQueue* obj = new MyQueue();
     * obj->push(x);
     * int param_2 = obj->pop();
     * int param_3 = obj->peek();
     * bool param_4 = obj->empty();
     */
    
    展开全文
  • LeetCode 225. 用队列实现栈 232. 用栈实现队列
  • python用栈实现队列

    2018-05-30 23:23:45
    python用栈实现队列,简单明了易于进一步思考和总结发散思维。
  • 1.用栈实现队列 使用栈实现队列的下列操作: push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 示例: MyQueue queue = new ...
  • 用栈实现队列-栈和队列学习 正如标题所述,你需要使用两个栈来实现队列的一些操作。 队列应支持push(element),pop() 和 top(),其中pop是弹出队列中的第一个(最前面的)元素。 pop和top方法都应该返回第一个元素的值...
  • 232. 用栈实现队列 使用栈实现队列的下列操作: push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 思路: 栈为后进先出...
  • 如何用栈实现队列结构及队列实现栈结构 双队列 双stack
  • Java实现 LeetCode 232 用栈实现队列

    万次阅读 多人点赞 2020-02-29 22:02:19
    232. 用栈实现队列 使用栈实现队列的下列操作: push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 示例: MyQueue queue = new ...
  • Java 用栈实现队列和用对列实现栈 前言 Leetcode 第225题用队列实现栈 Leetcode 第232题用栈实现队列 一、使用队列实现栈实现以下操作 push(int x) 将元素 x 压入栈顶。 pop() 移除并返回栈顶元素。 top() 返回栈顶...
  • 用栈实现队列 使用栈实现队列的下列操作: push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 示例: MyQueue queue = new ...
  • Leetcode 用栈实现队列

    2021-03-11 17:04:25
    文章目录用栈实现队列题目描述具体代码 用栈实现队列 题目描述 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty): 实现 MyQueue 类: void push(int x) 将元素 x...
  • 用栈实现队列(Java实现)

    千次阅读 2020-07-08 08:27:10
    用栈实现队列(力扣:232)
  • Implement Stack using Queues 用栈实现队列 首先我们得知道队列和栈的性质。 队列:先进先出。 栈:先进后出。 所以怎么用栈实现队列呢 怎么实现先进先出呢?用一个栈肯定是无法实现的,因为栈只有一个开口,所以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,492
精华内容 4,996
关键字:

用栈实现队列