用链表实现栈（Java版）

用链表实现栈

一、算法的思想

用链表实现栈的先进后出，实现栈的push，pop，peak方法。主要就是利用链表的头结点作为栈顶的元素。

1.当要push的时候，相当于新new一个头结点，然后让新节点指向单链表的头结点。以新节点作为单链表的头节点即可。

2.当要pop的时候，只要将链表的头指针后移到它的next，将next作为新的头结点即可

3.当要peak的时候，只要返回头结点的值就好了。

二、Java版实例

[java] view plain copy

1. /** 
2. /** 
3.  * 用单链表实现栈 
4.  *  
5.  * 表示链表的一个节点 
6.  * @author ly 
7.  * 
8.  */  
9. public class Node {  
10.       
11.     Object element;  
12.     Node next;  
13.       
14.     public Node(Object element){  
15.         this(element,null);  
16.     }  
17.       
18.     /** 
19.      * 创建一个新的节点 
20.      * 让他的next指向，参数中的节点 
21.      * @param element 
22.      * @param n 
23.      */  
24.     public Node(Object element,Node n){  
25.         this.element=element;  
26.         next=n;  
27.     }  
28.       
29.     public Object getElement() {  
30.         return element;  
31.     }  
32.       
33. }  

[java] view plain copy

1. /** 
2.  * 用链表实现的栈，内含push pop peak 方法 
3.  * @author ly 
4.  * 
5.  */  
6. public class ListStack {  
7.       
8.     Node header;//栈顶元素  
9.     int elementCount;//栈内元素个数  
10.     int size;//栈的大小  
11.       
12.     /** 
13.      * 构造函数，构造一个空的栈 
14.      */  
15.     public ListStack(){  
16.         header=null;  
17.         elementCount=0;  
18.         size=0;  
19.     }  
20.       
21.     /** 
22.      * 通过构造器自定义栈的大小 
23.      * @param size 
24.      */  
25.     public ListStack(int size) {  
26.         header=null;  
27.         elementCount=0;  
28.         this.size=size;  
29.     }  
30.       
31.     public void setHeader(Node header) {  
32.         this.header=header;  
33.     }  
34.       
35.     public boolean isFull() {  
36.         if (elementCount==size) {  
37.             return true;  
38.         }  
39.           
40.         return false;  
41.     }  
42.       
43.     public boolean isEmpty() {  
44.         if (elementCount==0) {  
45.             return true;  
46.         }  
47.           
48.         return false;  
49.     }  
50.       
51.     /** 
52.      * 入栈 
53.      * @param value 
54.      */  
55.     public void push(Object value) {  
56.         if (this.isFull()) {  
57.             throw new RuntimeException("Stack is Full");  
58.         }  
59.         //注意这里面试将原来的header作为参数传入，然后以新new出来的Node作为header  
60.         header=new Node(value, header);  
61.         elementCount++;  
62.     }  
63.       
64.     /** 
65.      * 出栈 
66.      * @return 
67.      */  
68.     public Object pop() {  
69.         if (this.isEmpty()) {  
70.             throw new RuntimeException("Stack is empty");  
71.         }  
72.         Object object=header.getElement();  
73.           
74.         header=header.next;  
75.           
76.         elementCount--;  
77.           
78.         return object;  
79.     }  
80.       
81.     /** 
82.      * 返回栈顶元素 
83.      */  
84.     public Object peak(){  
85.           
86.         if (this.isEmpty()) {  
87.             throw new RuntimeException("Stack is empty");  
88.         }  
89.           
90.         return header.getElement();  
91.     }  
92.   
93. }  

三、参考

用JAVA实现堆栈（链表篇）：http://blog.csdn.net/fengyifei11228/article/details/5625978