實現一個棧

1. public interface MyStack<T> {  
2.     /** 
3.      * 判斷棧是否爲空 
4.      */  
5.     boolean isEmpty();  
6.     /** 
7.      * 清空棧 
8.      */  
9.     void clear();  
10.     /** 
11.      * 棧的長度 
12.      */  
13.     int length();  
14.     /** 
15.      * 數據入棧 
16.      */  
17.     boolean push(T data);  
18.     /** 
19.      * 數據出棧 
20.      */  
21.     T pop();  
22. }  

棧的數組實現, 底層使用數組:

Java代碼

 

1. public class MyArrayStack<T> implements MyStack<T> {  
2.     private Object[] objs = new Object[16];  
3.     private int size = 0;  
4.   
5.     @Override  
6.     public boolean isEmpty() {  
7.         return size == 0;  
8.     }  
9.   
10.     @Override  
11.     public void clear() {  
12.         // 將數組中的數據置爲null, 方便GC進行回收  
13.         for (int i = 0; i < size; i++) {  
14.             objs[size] = null;  
15.         }  
16.         size = 0;  
17.     }  
18.   
19.     @Override  
20.     public int length() {  
21.         return size;  
22.     }  
23.   
24.     @Override  
25.     public boolean push(T data) {  
26.         // 判斷是否須要進行數組擴容  
27.         if (size >= objs.length) {  
28.             resize();  
29.         }  
30.         objs[size++] = data;  
31.         return true;  
32.     }  
33.   
34.     /** 
35.      * 數組擴容 
36.      */  
37.     private void resize() {  
38.         Object[] temp = new Object[objs.length * 3 / 2 + 1];  
39.         for (int i = 0; i < size; i++) {  
40.             temp[i] = objs[i];  
41.             objs[i] = null;  
42.         }  
43.         objs = temp;  
44.     }  
45.   
46.     @SuppressWarnings("unchecked")  
47.     @Override  
48.     public T pop() {  
49.         if (size == 0) {  
50.             return null;  
51.         }  
52.         return (T) objs[--size];  
53.     }  
54.   
55.     @Override  
56.     public String toString() {  
57.         StringBuilder sb = new StringBuilder();  
58.         sb.append("MyArrayStack: [");  
59.         for (int i = 0; i < size; i++) {  
60.             sb.append(objs[i].toString());  
61.             if (i != size - 1) {  
62.                 sb.append(", ");  
63.             }  
64.         }  
65.         sb.append("]");  
66.         return sb.toString();  
67.     }  
68. }    

棧的鏈表實現, 底層使用鏈表:

Java代碼

 

1. public class MyLinkedStack<T> implements MyStack<T> {  
2.     /** 
3.      * 棧頂指針 
4.      */  
5.     private Node top;  
6.     /** 
7.      * 棧的長度 
8.      */  
9.     private int size;  
10.       
11.     public MyLinkedStack() {  
12.         top = null;  
13.         size = 0;  
14.     }  
15.       
16.     @Override  
17.     public boolean isEmpty() {  
18.         return size == 0;  
19.     }  
20.       
21.     @Override  
22.     public void clear() {  
23.         top = null;  
24.         size = 0;  
25.     }  
26.       
27.     @Override  
28.     public int length() {  
29.         return size;  
30.     }  
31.       
32.     @Override  
33.     public boolean push(T data) {  
34.         Node node = new Node();  
35.         node.data = data;  
36.         node.pre = top;  
37.         // 改變棧頂指針  
38.         top = node;  
39.         size++;  
40.         return true;  
41.     }  
42.       
43.     @Override  
44.     public T pop() {  
45.         if (top != null) {  
46.             Node node = top;  
47.             // 改變棧頂指針  
48.             top = top.pre;  
49.             size--;  
50.             return node.data;  
51.         }  
52.         return null;  
53.     }  
54.       
55.     /** 
56.      * 將數據封裝成結點 
57.      */  
58.     private final class Node {  
59.         private Node pre;  
60.         private T data;  
61.     }  
62. }  

兩種實現的比較, 主要比較數據入棧和出棧的速度:

Java代碼

 

1. @Test  
2. public void testSpeed() {  
3.     MyStack<Person> stack = new MyArrayStack<Person>();  
4.     int num = 10000000;  
5.     long start = System.currentTimeMillis();  
6.     for (int i = 0; i < num; i++) {  
7.         stack.push(new Person("xing", 25));  
8.     }  
9.     long temp = System.currentTimeMillis();  
10.     System.out.println("push time: " + (temp - start));  
11.     while (stack.pop() != null)  
12.         ;  
13.     System.out.println("pop time: " + (System.currentTimeMillis() - temp));  
14. }  

MyArrayStack中入棧和出棧10,000,000條數據的時間:

push time: 936

pop time: 47

將MyArrayStack改成MyLinkedStack後入棧和出棧的時間:

push time: 936

pop time: 126

可見二者的入棧速度差很少, 出棧速度MyArrayStack則有明顯的優點.

爲何測試結果是這樣的? 可能有些朋友的想法是數組實現的棧應該具備更快的遍歷速度, 但增刪速度應該比不上鍊表實現的棧纔對. 可是棧中數據的增刪具備特殊性: 只在棧頂入棧和出棧. 也就是說數組實現的棧在增長和刪除元素時並不須要移動大量的元素, 只是在數組擴容時須要進行復制. 而鏈表實現的棧入棧和出棧時都須要將數據包裝成Node或者從Node中取出數據, 還須要維護棧頂指針和前驅指針. 

 

棧的應用舉例

1. 將10進制正整數num轉換爲n進制

Java代碼

 

1. private String conversion(int num, int n) {  
2.     MyStack<Integer> myStack = new MyArrayStack<Integer>();  
3.     Integer result = num;  
4.     while (true) {  
5.         // 將餘數入棧  
6.         myStack.push(result % n);  
7.         result = result / n;  
8.         if (result == 0) {  
9.             break;  
10.         }  
11.     }  
12.     StringBuilder sb = new StringBuilder();  
13.     // 按出棧的順序倒序排列便可  
14.     while ((result = myStack.pop()) != null) {  
15.         sb.append(result);  
16.     }  
17.     return sb.toString();  
18. }  

2. 檢驗符號是否匹配. '['和']', '('和')'成對出現時字符串合法. 例如"[][]()", "[[([]([])()[])]]"是合法的; "([(])", "[())"是不合法的.

遍歷字符串的每個char, 將char與棧頂元素比較. 若是char和棧頂元素配對, 則char不入棧, 不然將char入棧. 當遍歷完成時棧爲空說明字符串是合法的.

Java代碼

 

1. public boolean isMatch(String str) {  
2.     MyStack<Character> myStack = new MyArrayStack<Character>();  
3.     char[] arr = str.toCharArray();  
4.     for (char c : arr) {  
5.         Character temp = myStack.pop();  
6.         // 棧爲空時只將c入棧  
7.         if (temp == null) {  
8.             myStack.push(c);  
9.         }  
10.         // 配對時c不入棧  
11.         else if (temp == '[' && c == ']') {  
12.         }   
13.         // 配對時c不入棧  
14.         else if (temp == '(' && c == ')') {  
15.         }   
16.         // 不配對時c入棧  
17.         else {  
18.             myStack.push(temp);  
19.             myStack.push(c);  
20.         }  
21.     }  
22.     return myStack.isEmpty();  
23. }  

3. 行編輯: 輸入行中字符'#'表示退格, '@'表示以前的輸入全都無效.

使用棧保存輸入的字符, 若是遇到'#'就將棧頂出棧, 若是遇到@就清空棧. 輸入完成時將棧中全部字符出棧後反轉就是輸入的結果:

Java代碼

 

1. private String lineEdit(String input) {  
2.     MyStack<Character> myStack = new MyArrayStack<Character>();  
3.     char[] arr = input.toCharArray();  
4.     for (char c : arr) {  
5.         if (c == '#') {  
6.             myStack.pop();  
7.         } else if (c == '@') {  
8.             myStack.clear();  
9.         } else {  
10.             myStack.push(c);  
11.         }  
12.     }  
13.       
14.     StringBuilder sb = new StringBuilder();  
15.     Character temp = null;  
16.     while ((temp = myStack.pop()) != null) {  
17.         sb.append(temp);  
18.     }  
19.     // 反轉字符串  
20.     sb.reverse();  
21.     return sb.toString();  
22. } 

 

或者

棧數組實現一：優勢：入棧和出棧速度快，缺點：長度有限(有時候這也不能算是個缺點)

[java] view plain copy

 

1. public class Stack {  
2.     private int top = -1;  
3.     private Object[] objs;  
4.       
5.     public Stack(int capacity) throws Exception{  
6.         if(capacity < 0)  
7.             throw new Exception("Illegal capacity:"+capacity);  
8.         objs = new Object[capacity];  
9.     }  
10.       
11.     public void push(Object obj) throws Exception{  
12.         if(top == objs.length - 1)  
13.             throw new Exception("Stack is full!");  
14.         objs[++top] = obj;  
15.     }  
16.       
17.     public Object pop() throws Exception{  
18.         if(top == -1)  
19.             throw new Exception("Stack is empty!");  
20.         return objs[top--];  
21.     }  
22.       
23.     public void dispaly(){  
24.         System.out.print("bottom -> top: | ");  
25.         for(int i = 0 ; i <= top ; i++){  
26.             System.out.print(objs[i]+" | ");  
27.         }  
28.         System.out.print("\n");  
29.     }  
30.       
31.     public static void main(String[] args) throws Exception{  
32.         Stack s = new Stack(2);  
33.         s.push(1);  
34.         s.push(2);  
35.         s.dispaly();  
36.         System.out.println(s.pop());  
37.         s.dispaly();  
38.         s.push(99);  
39.         s.dispaly();  
40.         s.push(99);  
41.     }  
42. }  

[plain] view plain copy

 

1. bottom -> top: | 1 | 2 |   
2. 2  
3. bottom -> top: | 1 |   
4. bottom -> top: | 1 | 99 |   
5. Exception in thread "main" java.lang.Exception: Stack is full!  
6.     at Stack.push(Stack.java:17)  
7.     at Stack.main(Stack.java:44)  

數據項入棧和出棧的時間複雜度都爲常數O(1)

 

棧數組實現二：優勢：無長度限制，缺點：入棧慢

[java] view plain copy

 

1. import java.util.Arrays;  
2.   
3. public class UnboundedStack {  
4.     private int top = -1;  
5.     private Object[] objs;  
6.       
7.     public UnboundedStack() throws Exception{  
8.         this(10);  
9.     }  
10.       
11.     public UnboundedStack(int capacity) throws Exception{  
12.         if(capacity < 0)  
13.             throw new Exception("Illegal capacity:"+capacity);  
14.         objs = new Object[capacity];  
15.     }  
16.       
17.     public void push(Object obj){  
18.         if(top == objs.length - 1){  
19.             this.enlarge();  
20.         }  
21.         objs[++top] = obj;  
22.     }  
23.       
24.     public Object pop() throws Exception{  
25.         if(top == -1)  
26.             throw new Exception("Stack is empty!");  
27.         return objs[top--];  
28.     }  
29.       
30.     private void enlarge(){  
31.         int num = objs.length/3;  
32.         if(num == 0)  
33.             num = 1;  
34.         objs = Arrays.copyOf(objs, objs.length + num);  
35.     }  
36.       
37.     public void dispaly(){  
38.         System.out.print("bottom -> top: | ");  
39.         for(int i = 0 ; i <= top ; i++){  
40.             System.out.print(objs[i]+" | ");  
41.         }  
42.         System.out.print("\n");  
43.     }  
44.       
45.     public static void main(String[] args) throws Exception{  
46.         UnboundedStack us = new UnboundedStack(2);  
47.         us.push(1);  
48.         us.push(2);  
49.         us.dispaly();  
50.         System.out.println(us.pop());  
51.         us.dispaly();  
52.         us.push(99);  
53.         us.dispaly();  
54.         us.push(99);  
55.         us.dispaly();  
56.     }  
57. }  

[plain] view plain copy

 

1. bottom -> top: | 1 | 2 |   
2. 2  
3. bottom -> top: | 1 |   
4. bottom -> top: | 1 | 99 |   
5. bottom -> top: | 1 | 99 | 99 |   

因爲該棧是由數組實現的，數組的長度是固定的，當棧空間不足時，必須將原數組數據複製到一個更長的數組中，考慮到入棧時或許須要進行數組複製，平均須要複製N/2個數據項，故入棧的時間複雜度爲O(N)，出棧的時間複雜度依然爲O(1)

 

棧單鏈表實現：沒有長度限制，而且出棧和入棧速度都很快

[java] view plain copy

 

1. public class LinkedList {  
2.     private class Data{  
3.         private Object obj;  
4.         private Data next = null;  
5.           
6.         Data(Object obj){  
7.             this.obj = obj;  
8.         }  
9.     }  
10.       
11.     private Data first = null;  
12.       
13.     public void insertFirst(Object obj){  
14.         Data data = new Data(obj);  
15.         data.next = first;  
16.         first = data;  
17.     }  
18.       
19.     public Object deleteFirst() throws Exception{  
20.         if(first == null)  
21.             throw new Exception("empty!");  
22.         Data temp = first;  
23.         first = first.next;  
24.         return temp.obj;  
25.     }  
26.               
27.     public void display(){  
28.         if(first == null)  
29.             System.out.println("empty");  
30.         System.out.print("top -> bottom : | ");  
31.         Data cur = first;  
32.         while(cur != null){  
33.             System.out.print(cur.obj.toString() + " | ");  
34.             cur = cur.next;  
35.         }  
36.         System.out.print("\n");  
37.     }  
38. }  

[java] view plain copy

 

1. public class LinkedListStack {  
2.     private LinkedList ll = new LinkedList();  
3.       
4.     public void push(Object obj){  
5.         ll.insertFirst(obj);  
6.     }  
7.       
8.     public Object pop() throws Exception{  
9.         return ll.deleteFirst();  
10.     }  
11.       
12.     public void display(){  
13.         ll.display();  
14.     }  
15.       
16.     public static void main(String[] args) throws Exception{  
17.         LinkedListStack lls = new LinkedListStack();  
18.         lls.push(1);  
19.         lls.push(2);  
20.         lls.push(3);  
21.         lls.display();  
22.         System.out.println(lls.pop());  
23.         lls.display();  
24.     }  
25. }  

[plain] view plain copy

 

1. top -> bottom : | 3 | 2 | 1 |   
2. 3  
3. top -> bottom : | 2 | 1 |   

數據項入棧和出棧的時間複雜度都爲常數O(1)

 

 

/**
 * 基於數組實現的順序棧
 * @param <E>
 */
public class Stack<E> {
    private Object[] data = null;
    private int maxSize=0;   //棧容量
    private int top =-1;  //棧頂指針
    
    /**
     * 構造函數：根據給定的size初始化棧
     */
    Stack(){
        this(10);   //默認棧大小爲10
    }
    
    Stack(int initialSize){
        if(initialSize >=0){
            this.maxSize = initialSize;
            data = new Object[initialSize];
            top = -1;
        }else{
            throw new RuntimeException("初始化大小不能小於0：" + initialSize);
        }
    }
    
    //判空
    public boolean empty(){
        return top==-1 ? true : false;
    }
    
    //進棧,第一個元素top=0；
    public boolean push(E e){
        if(top == maxSize -1){
            throw new RuntimeException("棧已滿，沒法將元素入棧！");
        }else{
            data[++top]=e;
            return true;
        }    
    }
    
    //查看棧頂元素但不移除
    public E peek(){
        if(top == -1){
            throw new RuntimeException("棧爲空！");
        }else{
            return (E)data[top];
        }
    }
    
    //彈出棧頂元素
    public E pop(){
        if(top == -1){
            throw new RuntimeException("棧爲空！");
        }else{
            return (E)data[top--];
        }
    }
    
    //返回對象在堆棧中的位置，以 1 爲基數
    public int search(E e){
        int i=top;
        while(top != -1){
            if(peek() != e){
                top --;
            }else{
                break;
            }
        }
        int result = top+1;
        top = i;
        return result;      
    }
}

棧的鏈式存儲結構實現：

public class LinkStack<E> {
    //鏈棧的節點
    private class Node<E>{
        E e;
        Node<E> next;
        
        public Node(){}
        public Node(E e, Node next){
            this.e = e;
            this.next = next;
        }
    }
    
    private Node<E> top;   //棧頂元素
    private int size;  //當前棧大小
    
    public LinkStack(){
        top = null;
    }
    
    //當前棧大小
    public int length(){
        return size;
    }
    
    //判空
    public boolean empty(){
        return size==0;
    }
    
    //入棧：讓top指向新建立的元素，新元素的next引用指向原來的棧頂元素
    public boolean push(E e){
        top = new Node(e,top);
        size ++;
        return true;
    }
    
    //查看棧頂元素但不刪除
    public Node<E> peek(){
        if(empty()){
            throw new RuntimeException("空棧異常！");
        }else{
            return top;
        }
    }
    
    //出棧
    public Node<E> pop(){
        if(empty()){
            throw new RuntimeException("空棧異常！");
        }else{
            Node<E> value = top; //獲得棧頂元素
            top = top.next; //讓top引用指向原棧頂元素的下一個元素 
            value.next = null;  //釋放原棧頂元素的next引用
            size --;
            return value;
        }
    }
}

 

基於LinkedList實現的棧結構：

import java.util.LinkedList;

/**
 * 基於LinkedList實現棧
 * 在LinkedList實力中只選擇部分基於棧實現的接口
 */
public class StackList<E> {
    private LinkedList<E> ll = new LinkedList<E>();
    
    //入棧
    public void push(E e){
        ll.addFirst(e);
    }
    
    //查看棧頂元素但不移除
    public E peek(){
        return ll.getFirst();
    }
    
    //出棧
    public E pop(){
        return ll.removeFirst();
    }
    
    //判空
    public boolean empty(){
        return ll.isEmpty();
    }
    
    //打印棧元素
    public String toString(){
        return ll.toString();
    }
}