目录
(1)栈的创建
(2)队列的创建
(3)两个栈实现一个队列
(4)两个队列实现一个栈
(5)设计含最小函数min()的栈,要求min、push、pop、的时间复杂度都是O(1)
(6)判断栈的push和pop序列是否一致
1、栈的创建:
我们接下来通过链表的形式来创建栈,方便扩充。
代码实现:
public class Stack {public Node head; public Node current; public void push(int data) { if (head == null) { head = new Node(data); current = head; } else { Node node = new Node(data); node.pre = current; current = node; } }public Node pop() { if (current == null) { return null; }Node node = current; current = current.pre; return node;}class Node { int data; Node pre; public Node(int data) { this.data = data; } }public static void main(String[] args) {Stack stack = new Stack(); stack.push(1); stack.push(2); stack.push(3);System.out.println(stack.pop().data); System.out.println(stack.pop().data); System.out.println(stack.pop().data); }}
- 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
入栈操作时,14、15行代码是关键。
运行效果:
2、队列的创建:
队列的创建有两种形式:基于数组结构实现(顺序队列)、基于链表结构实现(链式队列)。
我们接下来通过链表的形式来创建队列,这样的话,队列在扩充时会比较方便。队列在出队时,从头结点head开始。
代码实现:
入栈时,和在普通的链表中添加结点的操作是一样的;出队时,出的永远都是head结点。
public class Queue { public Node head; public Node curent; public void add(int data) { if (head == null) { head = new Node(data); curent = head; } else { curent.next = new Node(data); curent = curent.next; } } public int pop() throws Exception { if (head == null) { throw new Exception("队列为空"); }Node node = head; head = head.next; return node.data;}class Node { int data; Node next;public Node(int data) { this.data = data; } }public static void main(String[] args) throws Exception { Queue queue = new Queue(); for (int i = 0; i < 5; i++) { queue.add(i); } System.out.println(queue.pop()); System.out.println(queue.pop()); System.out.println(queue.pop());}}
- 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
运行效果:
3、两个栈实现一个队列:
思路:
栈1用于存储元素,栈2用于弹出元素,负负得正。
说的通俗一点,现在把数据1、2、3分别入栈一,然后从栈一中出来(3、2、1),放到栈二中,那么,从栈二中出来的数据(1、2、3)就符合队列的规律了,即负负得正。
完整版代码实现:
import java.util.Stack;/*** Created by smyhvae on 2015/9/9.*/public class Queue {private Stack<Integer> stack1 = new Stack<>(); private Stack<Integer> stack2 = new Stack<>(); public void push(int data) { stack1.push(data);} public int pop() throws Exception {if (stack2.empty()) {while (!stack1.empty()) { stack2.push(stack1.pop()); }}if (stack2.empty()) { throw new Exception("队列为空"); }return stack2.pop(); }public static void main(String[] args) throws Exception { Queue queue = new Queue(); queue.push(1); queue.push(2); queue.push(3);System.out.println(queue.pop());queue.push(4);System.out.println(queue.pop()); System.out.println(queue.pop()); System.out.println(queue.pop());}}
- 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
注意第22行和第30行代码的顺序,以及注释,需要仔细理解其含义。
运行效果:
4、两个队列实现一个栈:
思路:
将1、2、3依次入队列一, 然后最上面的3留在队列一,将下面的2、3入队列二,将3出队列一,此时队列一空了,然后把队列二中的所有数据入队列一;将最上面的2留在队列一,将下面的3入队列二。。。依次循环。
代码实现:
import java.util.ArrayDeque;import java.util.Queue;/*** Created by smyhvae on 2015/9/9.*/public class Stack {Queue<Integer> queue1 = new ArrayDeque<Integer>(); Queue<Integer> queue2 = new ArrayDeque<Integer>(); public void push(int data) { queue1.add(data); } public int pop() throws Exception { int data; if (queue1.size() == 0) { throw new Exception("栈为空"); }while (queue1.size() != 0) { if (queue1.size() == 1) { data = queue1.poll(); while (queue2.size() != 0) { queue1.add(queue2.poll()); return data; } } queue2.add(queue1.poll()); } throw new Exception("栈为空"); }public static void main(String[] args) throws Exception { Stack stack = new Stack();stack.push(1); stack.push(2); stack.push(3);System.out.println(stack.pop()); System.out.println(stack.pop()); stack.push(4); }}
- 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
运行效果:
5、设计含最小函数min()的栈,要求min、push、pop、的时间复杂度都是O(1)。min方法的作用是:就能返回是栈中的最小值。【微信面试题】
普通思路:
一般情况下,我们可能会这么想:利用min变量,每次添加元素时,都和min元素作比较,这样的话,就能保证min存放的是最小值。但是这样的话,会存在一个问题:如果最小的元素出栈了,那怎么知道剩下的元素中哪个是最小的元素呢?
改进思路:
这里需要加一个辅助栈,用空间换取时间。辅助栈中,栈顶永远保存着当前栈中最小的数值。具体是这样的:原栈中,每次添加一个新元素时,就和辅助栈的栈顶元素相比较,如果新元素小,就把新元素的值放到辅助栈中,如果新元素大,就把辅助栈的栈顶元素再copy一遍放到辅助栈的栈顶;原栈中,出栈时,
完整代码实现:
import java.util.Stack;/*** Created by smyhvae on 2015/9/9.*/public class MinStack {private Stack<Integer> stack = new Stack<Integer>(); private Stack<Integer> minStack = new Stack<Integer>(); public void push(int data) { stack.push(data); if (minStack.size() == 0 || data < minStack.peek()) { minStack.push(data); } else { minStack.add(minStack.peek()); } }public int pop() throws Exception { if (stack.size() == 0) { throw new Exception("栈中为空"); }int data = stack.pop(); minStack.pop(); return data; }public int min() throws Exception { if (minStack.size() == 0) { throw new Exception("栈中空了"); } return minStack.peek(); }public static void main(String[] args) throws Exception { MinStack stack = new MinStack(); stack.push(4); stack.push(3); stack.push(5);System.out.println(stack.min()); }}
- 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
运行效果:
6、判断栈的push和pop序列是否一致:
通俗一点讲:已知一组数据1、2、3、4、5依次进栈,那么它的出栈方式有很多种,请判断一下给出的出栈方式是否是正确的?
例如:
数据:
1、2、3、4、5
出栈1:
5、4、3、2、1(正确)
出栈2:
4、5、3、2、1(正确)
出栈3:
4、3、5、1、2(错误)
完整版代码:
import java.util.Stack;/*** Created by smyhvae on 2015/9/9.*/public class StackTest { public static boolean sequenseIsPop(int[] data1, int[] data2) { Stack<Integer> stack = new Stack<Integer>(); for (int i = 0, j = 0; i < data1.length; i++) { stack.push(data1[i]);while (stack.size() > 0 && stack.peek() == data2[j]) { stack.pop(); j++; } } return stack.size() == 0; }public static void main(String[] args) {Stack<Integer> stack = new Stack<Integer>();int[] data1 = {1, 2, 3, 4, 5}; int[] data2 = {4, 5, 3, 2, 1}; int[] data3 = {4, 5, 2, 3, 1};System.out.println(sequenseIsPop(data1, data2)); System.out.println(sequenseIsPop(data1, data3)); }}
- 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
运行效果: