232.Implement Queue using Stacks(Stack-Easy)

用Stack实现Queue
本文介绍了一种使用两个栈(Stack)来模拟队列(Queue)的方法。通过分别定义输入栈和输出栈,使得能够实现队列的基本操作:push、pop、peek及empty。此方法巧妙地利用了栈的特性,实现了队列的先进先出(FIFO)原则。

转载请注明作者和出处:http://blog.csdn.net/c406495762

Implement the following operations of a queue using stacks.

  • push(x) – Push element x to the back of queue.

  • pop() – Removes the element from in front of queue.

  • peek() – Get the front element.

  • empty() – Return whether the queue is empty.

Notes:

  • You must use only standard operations of a stack – which means only push to top, peek/pop from top, size, and is empty operations are valid.

  • Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.

  • You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).

题目: 用Stacks实现Queue。

思路: Queue是先进先出FIFO,Stack是先进后出FILO。使用Stack模拟实现Queue的功能,可以使用两个Stack,一个进行入Stack操作,一个进行出Stack操作。这两个Stack中的元素位置是颠倒的。比如,一个元素在第一个Stack位于Stack头,那么这个元素在另一个Stack则位于Stack尾。

Language : cpp

class MyQueue {
public:

    stack<int> input, output;
    /** Push element x to the back of queue. */
    void push(int x) {
        input.push(x);
    }
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        int a = peek();
        output.pop();
        return a;
    }

    /** Get the front element. */
    int peek() {
        if(output.empty()){
            while(input.size()){
                output.push(input.top());
                input.pop();
            }
        }
        return output.top();
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return input.empty() && output.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();
 */
The goal of task 1 The goal of this exercise is to implement a Stack data structure. The implementation must pass all the tests included in the exercise. Time complexity requirements: capacity(): O(1). push(): O(1), except for when reallocation must be done: O(n). pop(): O(1). peek(): O(1). size(): O(1). isEmpty(): O(1). toString(): O(n). clear(): O(1). When implementing clear() you may decide yourself if you want to keep the current capacity or will the capacity be the default capacity of a queue. Note that the method toString() in this and later execises must be implemented using Java StringBuilder, not by using the String by modifying and appending to a String object. When handling large amounts of data elements, with String, this is hundreds of times slower than using StringBuilder. This has already been implemented for you. Prerequisites You have all the tools installed and working. This was tested in the 00-init exercise of the course. If you haven't done that yet, do it now. Instructions An overview of the classes in this exercise is shown in the UML class diagram below. Note that in this task, you only work with the StackImplementation class. The class ParenthesisTChecker.java and StackFactory.createCharacterStack() are not needed until you start working with the additional tasks. If you want to, you may crete your own main app file, for example in src/main/java/oy/tol/tra/Main.java, where you may implement your own main() method to experiment with your stack implementation. However, the main goal of the exercise is to pass all the unit tests. Do not implement main() method to data structure classes or test classes! Before delivery, remove all main functions an any unnrcessary test code. UML class diagram You should implement the interface StackInterface in the StackImplementation.java which is already created for you and located in this project's src/main/java/oy/tol/tra/ directory! Note that the StackImplementation uses E template parameter for the StackInterface: public class StackImplementation<E> implements StackInterface<E> { So the stack is a generic (template) class. Make sure to read the StackInterface documentation (the comments in the code) carefully so that your implementation follows the interface documentation. Obviously you need to know how stacks work in general, so check out the course lectures and other material on stack data structures. In this exercise, you use the Java plain array as the internal data structure for holding the elements: private Object [] itemArray; Since all Java classes inherit from Object, we can create an array of Objects for the elements. In the StackImplemention, constructors, follow the code comments and allocate the array of elements, in addition to other things you need to implement: itemArray = new Object[capacity]; Make sure to implement reallocating more room in the StackImplementation internal array if array is already full, when push() is called! After you have implemented your stack class methods, you can see that it is already instantiated for you in StackFactory.createIntegerStack(). After this, you are ready to test your implementation.
最新发布
03-08
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jack-Cui

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值