FilesExpand file tree

 master

/

ImplementQueueUsingStacks232.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

81 lines (69 loc) · 2.21 KB

 master

/

ImplementQueueUsingStacks232.java

Copy path

Top

File metadata and controls

• Code
• Blame

81 lines (69 loc) · 2.21 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

/**

* 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.

*

* Example:

*

* MyQueue queue = new MyQueue();

*

* queue.push(1);

* queue.push(2);

* queue.peek(); // returns 1

* queue.pop(); // returns 1

* queue.empty(); // returns false

*

* 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).

*/

public class ImplementQueueUsingStacks232 {

class MyQueue {

private Stack<Integer> st;

/** Initialize your data structure here. */

public MyQueue() {

this.st = new Stack<Integer>();

}

/** Push element x to the back of queue. */

public void push(int x) {

Stack<Integer> temp = new Stack<>();

int preSize = this.st.size();

for (int i=0; i<preSize; i++) {

temp.push(this.st.pop());

}

this.st.push(x);

for (int i=0; i<preSize; i++) {

this.st.push(temp.pop());

}

}

/** Removes the element from in front of queue and returns that element. */

public int pop() {

return this.st.pop();

}

/** Get the front element. */

public int peek() {

return this.st.peek();

}

/** Returns whether the queue is empty. */

public boolean empty() {

return this.st.isEmpty();

}

}

}

/**

* 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();

* boolean param_4 = obj.empty();

*/