栈定义

                    栈(stack):是一种特殊的串行形式的数据结构，其特殊之处在于只允许在链接串行或者阵列的

              一端进行插入、删除操作。其实现方式可以通过一维阵列和链接串行来实现。

                   Tips：简单的来说栈其实也是一种操作受限的线性表。是一种后进先出的数据结构可以使用数

                               组或者链表的形式来实现。

                    栈的操作表现形式:

                           

        栈实现

                     知道了栈的定义，我们来看看栈的实现吧。首先我们需要明白的的是栈具有哪些操作。

                通过一个接口定义其操作。        

package com.kiritor; /**  * 栈操作定义  * @author Kiritor*/ public interface Stack<T> {     /*判空*/     boolean isEmpty();     /*清空栈*/     void clear();     /*弹栈*/     T pop();     /*入栈*/     boolean push(T data);     /*栈的长度*/     int length();     /*查看栈顶的元素，但不移除它*/     T peek();     /*返回对象在栈中的位置*/     int search(T t); }

           栈的数组实现

                     栈的数组实现，底层使用数组              

package com.kiritor; /**  * 栈的数组实现  * @author Kiritor*/ public class ArrayStack<T> implements Stack<T>{ 	 	private T[] t = (T[]) new Object[16];//栈空间默认为16     private int size = 0; 	@Override 	public boolean isEmpty() { 		return size==0; 	}  	@Override 	public void clear() { 		for(int i = 0;i<t.length;i++) 			t[i]=null;//将其引用只为null，方便gc进行回收 		size = 0;//栈的大小置0 	}  	/*弹栈操作*/ 	@Override 	public T pop() { 		if(size==0) 		   return null; 		else 		{ 		    T tmp = t[size-1]; 		    t[size-1]=null;//便于gc回收 		    size--; 		    return tmp; 		} 	}  	@Override 	public boolean push(T data) { 		if(size>=t.length) 		{ 			//栈空间已满，需要扩容 			resize(); 		} 		t[size++]=data; 		return true; 	}  	public void resize() 	{ 		T[] tmp = (T[]) new Object[t.length*2]; 		for(int i = 0;i<t.length;i++){ 			tmp[i]=t[i]; 			t[i]=null;//便于gc处理 		} 		t = tmp; 		tmp = null;//便于gc处理，提高程序效率 	} 	@Override 	public int length() { 		return size; 	}  	/*查看栈顶元素，但是并不删除*/ 	@Override 	public T peek() { 		if(size==0) 			   return null; 			else 			{ 			    return t[size-1]; 			} 	}     /*下表从1开始*/ 	@Override 	public int search(T t) { 		for(int i= 0;i<size;i++) 			if(t.equals(this.t[i])) 				return i+1; 		return 0; 	} 	 	@Override 	public String toString() { 		 StringBuilder sb = new StringBuilder();   	        sb.append("ArrayStack:\n[\n");   	        for (int i = size-1; i >=0; i--) {   	            sb.append("   "+t[i].toString());   	            if (i != size + 1) {   	                sb.append("\n");   	            }   	        }   	        sb.append("]");   	        return sb.toString();   	} 	    }
                 测试代码： 
public static void main(String[] args) {         ArrayStack<String> arrayStack = new ArrayStack<>();         arrayStack.push("C语言");         arrayStack.push("C++");         arrayStack.push("JAVA");         arrayStack.push("数据结构");         arrayStack.pop();         arrayStack.peek();         arrayStack.pop();         System.out.println(arrayStack.toString()); 	}
              输出结果：

                     

           栈的链表实现

              

package com.kiritor; /**  * 栈的链表实现  * @author Kiritor*/ public class LinkStack<T> implements Stack<T>{ 	 	/*将数据封装成结点*/     class Node     {     	private Node pre;     	private T data;     }          /*栈顶指针*/     private Node top;     private int size;//栈的大小     public LinkStack() { 		this.top = null; 		this.size = 0; 	} 	@Override 	public boolean isEmpty() { 		return size==0; 	}  	@Override 	public void clear() { 		top = null; 		size = 0; 		 	}  	@Override 	public T pop() { 		if (top != null) {               T t = top.data;             // 改变栈顶指针               top = top.pre;               size--;               return t;           }           return null;  	}  	@Override 	public boolean push(T data) { 		 Node node = new Node();   	     node.data = data;   	     node.pre = top;   	        // 改变栈顶指针   	    top = node;   	    size++;   	    return true;   	}  	@Override 	public int length() { 		return size; 	}  	@Override 	public T peek() { 		return top.data; 	}      /*下表从1开始*/ 	@Override 	public int search(T t) { 		int count=0; 		for(Node node= top;node.pre!=null;node = node.pre) 		{ 			count++; 			if(t.equals(node.data)) 		        return size - count; 		} 		return 0; 	} 	@Override 	public String toString() { 		 StringBuilder sb = new StringBuilder();   	        sb.append("LinkStack:"+length()+"\n[\n");   	        int count=0; 	        for (Node node = top;node!=null;node=node.pre) {   	            count++; 	        	sb.append("   "+node.data.toString());   	            if (count != size + 1) {   	                sb.append("\n");   	            }   	        }   	        sb.append("]");  	        System.out.println(count); 	        return sb.toString();   	}  	 }
                测试代码： 
	public static void main(String[] args) { 		 LinkStack<String> arrayStack = new LinkStack<>(); 	        arrayStack.push("C语言"); 	        arrayStack.push("C++"); 	        arrayStack.push("JAVA"); 	        arrayStack.push("数据结构"); 	         	        System.out.println(arrayStack.toString()); 	}
                       结果就不贴出了
                       因为栈操作的特殊性，一般来说以数组方式实现的栈的效率是要高于链表实现的，

                  原因在于：其一数组的访问更快。其二由于只在栈顶进行操作并未涉及太大的元素移动

                  但是使用链式实现将数据包装成Node，在从其中取数据，还的维护栈顶指针和前驱指针。