Java中栈的两种实现

栈是先进后出的数据结构，主要有弹栈，入栈两种操作。

数组版

  1 package stack;
  2
  3 /***
  4  * 栈的数组实现--java
  5  * 栈是先进后出的数据结构，主要有弹栈，入栈两种操作
  6  * 由于该栈是由数组实现的，数组的长度是固定的，当栈空间不足时，
  7  * 必须将原数组数据复制到一个更长的数组中，
  8  * 考虑到入栈时或许需要进行数组复制，平均需要复制N/2个数据项，
  9  * 故入栈的时间复杂度为O(N)，出栈的时间复杂度依然为O(1)
 10  * @author bink
 11  *
 12  */
 13 public class Stack_Array {
 14     private Object[] stack;//容器
 15     private static final int INIT_SIZE = 2;//栈的默认大小
 16     private int index;//栈顶索引
 17
 18     /**
 19      * 初始化栈_默认构造方法
 20      */
 21     public Stack_Array(){
 22         stack = new Object[INIT_SIZE];
 23         index = -1;
 24     }
 25
 26     /**
 27      * 初始化栈，自定义长度
 28      */
 29     public Stack_Array(int init_size){
 30         if(init_size<0){
 31             throw new RuntimeException();
 32         }
 33         stack = new Object[init_size];
 34         index = -1;
 35     }
 36
 37     /**
 38      * 判断栈是否为空
 39      * @return
 40      */
 41     public boolean isEmpty(){
 42         return index==-1;
 43     }
 44
 45     /**
 46      * 判断是都栈满
 47      * @return
 48      */
 49     public boolean isFull(){
 50         return index>=stack.length-1;
 51     }
 52
 53     /**
 54      * 入栈
 55      * @param obj
 56      */
 57     public synchronized void push(Object obj){
 58         if(isFull()){
 59             //动态扩容
 60             Object[] temp = stack;
 61             stack = new Object[stack.length*2];
 62             System.arraycopy(temp, 0, stack, 0, temp.length);
 63         }
 64         stack[++index] = obj;
 65     }
 66
 67     /**
 68      * 查看栈顶元素
 69      * @return
 70      */
 71     public Object peek(){
 72         if(!isEmpty()){
 73             return stack[index];
 74         }
 75         return null;
 76     }
 77
 78     /**
 79      * 出栈
 80      * @return
 81      */
 82     public synchronized Object pop(){
 83         if(!isEmpty()){
 84             Object obj = peek();
 85             stack[index--] = null;
 86             return obj;
 87         }
 88         return null;
 89     }
 90
 91     public static void main(String[] args) {
 92         Stack_Array stack = new Stack_Array();
 93         for(int i=0;i<100;i++){
 94             stack.push("stack"+i);
 95         }
 96         for(int i=0;i<100;i++){
 97             System.out.println(stack.pop());
 98         }
 99     }
100 }

链表版

 1 package stack;
 2
 3 /**
 4  * 栈的链表实现--java
 5  * @author bink
 6  *
 7  * @param <T>
 8  */
 9 public class LindedStack<T> {、
10     private class Node<T>{
11         //指向下一个节点
12         Node next;
13         //本节点存储的元素
14         T date;
15     }
16
17     //栈中存储的元素的数量
18     private int count;
19     //栈顶元素
20     private Node<T> top;
21
22     public LindedStack(){
23         count = 0;
24         top = null;
25     }
26
27     /**
28      * 判断是都为空
29      * @return true为空
30      */
31     public boolean isEmpty(){
32         return count==0;
33     }
34
35     /**
36      * 入栈
37      * @param element
38      */
39     public void push(T element){
40         Node<T> node = new Node<T>();//链表节点
41         node.date = element;//链表节点数据
42         node.next = top;//链表下一步节点
43         top = node;//现在的栈顶
44         count++;//栈数量
45     }
46
47     /**
48      * 出栈
49      * @return
50      */
51     public T pop(){
52         if(isEmpty()){
53             throw new RuntimeException();
54         }
55         T result = top.date;
56         top = top.next;
57         count--;
58         return result;
59     }
60
61     /**
62      * 获取栈顶
63      * @return
64      */
65     public T peek(){
66         if(isEmpty()){
67             throw new RuntimeException();
68         }
69         return top.date;
70     }
71
72     public static void main(String[] args) {
73         LindedStack<String> lind = new LindedStack<String>();
74         for(int i=0;i<10;i++){
75             lind.push("LindedStack"+i);
76         }
77         for(int i=0;i<10;i++){
78             System.out.println(lind.pop());
79         }
80     }
81 }