[数据结构与算法]栈Stack的多种实现

 1 package stack;
 2 
 3 /**
 4  * 栈接口
 5  * @author jzj
 6  *
 7  * @param <E>
 8  */
 9 public interface Stack<E> {
10     //入栈
11     public void push(E e);
12 
13     //出栈
14     public E pop();
15 
16     //取栈顶元素
17     public E peek();
18 
19     //当前栈大小
20     public int size();
21 
22     //栈是否为空
23     public boolean isEmpty();
24 }
 1 package stack;
 2 
 3 /**
 4  * 使用 单链表 实现栈
 5  * @author jzj
 6  *
 7  * @param <E>
 8  */
 9 public class LinkedStack<E> implements Stack<E> {
10     private class Node {
11         E data;//数据域
12         Node next;//next域
13 
14         Node() {//栈底元素构造函数
15             data = null;
16             next = null;
17         }
18 
19         /**
20          * 非栈底元素构造函数
21          * @param data 数据域
22          * @param next 新建节点next域指向
23          */
24         Node(E data, Node next) {
25             this.data = data;
26             this.next = next;
27         }
28 
29         //是否到栈底元素
30         boolean isEnd() {
31             return data == null && next == null;
32         }
33     }
34 
35     /*
36      * 栈顶元素,刚开始时创建一个data与next域都为null的节点,它是一个标志性节点,
37      * 也相当于栈底,如判断栈是否为空就可以使用它:如果top指向了这个节点,就表明已
38      * 到栈底了,即栈为空
39      */
40     private Node top = new Node();
41 
42     //入栈
43     public void push(E data) {
44         //让栈顶指向新建节点
45         top = new Node(data, top);
46     }
47 
48     //出栈
49     public E pop() {
50         //该节点可能是栈底元素,如果是则返回为null
51         E data = top.data;
52         if (!top.isEnd()) {//如果不是栈底,则指向下一个元素
53             top = top.next;
54         }
55         return data;
56     }
57 
58     //取栈顶元素
59     public E peek() {
60         //该节点可能是栈底元素,如果是则返回为null
61         return top.data;
62     }
63 
64     //栈大小
65     public int size() {
66         int size = 0;
67         Node tmpTop = top;
68         while (tmpTop.next != null) {
69             size++;
70             tmpTop = tmpTop.next;
71         }
72         return size;
73     }
74 
75     //栈是否为空
76     public boolean isEmpty() {
77         return top.isEnd();
78     }
79 }
 1 package stack;
 2 
 3 import java.util.LinkedList;
 4 
 5 /**
 6  * 使用 LinkedList 实现栈
 7  * @author jzj
 8  *
 9  * @param <E>
10  */
11 public class LinkedListStack<E> implements Stack<E> {
12     private LinkedList<E> list = new LinkedList<E>();
13 
14     //入栈
15     public void push(E e) {
16         list.addFirst(e);
17     }
18 
19     //出栈
20     public E pop() {
21         return list.removeFirst();
22     }
23 
24     //取栈顶元素
25     public E peek() {
26         return list.getFirst();
27     }
28 
29     //当前栈大小
30     public int size() {
31         return list.size();
32     }
33 
34     //栈是否为空
35     public boolean isEmpty() {
36         return list.isEmpty();
37     }
38 }
 1 package stack;
 2 
 3 /**
 4  * 使用 数组 实现栈
 5  * @author jzj
 6  *
 7  * @param <E>
 8  */
 9 public class ArrayStack<E> implements Stack<E> {
10     private E[] data;
11     private int top = -1;//指向栈顶元素
12     private int size = 3;
13 
14     public ArrayStack() {
15         data = (E[]) new Object[size];
16     }
17 
18     //入栈
19     public void push(E e) {
20         if ((top + 1) == size) {
21             throw new IllegalStateException("stack full...");
22         }
23         data[++top] = e;
24     }
25 
26     //出栈
27     public E pop() {
28         if (top == -1) {
29             throw new IllegalStateException("stack empty...");
30         }
31         E tmp = data[top];
32         //用完后释放对象,加快垃圾回收,防止大的对象不用发生内存泄露
33         data[top] = null;
34         top--;
35         return tmp;
36     }
37 
38     //取栈顶元素
39     public E peek() {
40         if (top == -1) {
41             throw new IllegalStateException("stack empty...");
42         }
43         return data[top];
44     }
45 
46     //当前栈大小
47     public int size() {
48         return top + 1;
49     }
50 
51     //栈是否为空
52     public boolean isEmpty() {
53         return top == -1;
54     }
55 }
 1 package stack;
 2 
 3 import java.util.ArrayList;
 4 
 5 /**
 6  * 使用 ArrayList 实现栈
 7  * @author jzj
 8  *
 9  * @param <E>
10  */
11 public class ArrayListStack<E> implements Stack<E> {
12     private ArrayList<E> list = new ArrayList<E>();
13 
14     //入栈
15     public void push(E e) {
16         list.add(e);//ArrayList默认就是在数组尾加入元素,从后面进
17     }
18 
19     //出栈
20     public E pop() {
21         return list.remove(list.size() - 1);//从前面出
22     }
23 
24     //取栈顶元素
25     public E peek() {
26         return list.get(list.size() - 1);
27     }
28 
29     //当前栈大小
30     public int size() {
31         return list.size();
32     }
33 
34     //栈是否为空
35     public boolean isEmpty() {
36         return list.isEmpty();
37     }
38 }
posted @ 2015-02-13 10:52  江正军  阅读(516)  评论(0编辑  收藏  举报