栈的实现(JAVA)

        栈定义

                    栈(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，在从其中取数据，还的维护栈顶指针和前驱指针。