java 實現數據結構之棧

在學數據結構課程時，對棧的最大特點是是後進先出（First In Last Out），對棧的操作主要是入棧和出棧，判斷棧是否爲空，計算棧的大小。
棧是一種數據結構，它代表只能在某一端進行插入、刪除操作的特殊線性表。對棧而言，允許插入刪除的一端是棧頂，另一端則稱爲棧底。
[color=red]1.棧的順序存儲實現：[/color]

public class Stack 
{
	//存放棧內元素的數組
	private Object[] elementData; 
	//記錄棧內元素的個數
	private int size = 0;
	//以指定初始化容量創建一個Stack
	private int capacityIncrement;
	//以指定初始化容量創建一個Stack
	public Stack(int initialCapacity) 
	{
		elementData = new Object[initialCapacity];
	}
	public Stack(int initialCapacity , int capacityIncrement)
	{
		this(initialCapacity);
		this.capacityIncrement = capacityIncrement;
	}
	//向“棧”頂壓入一個元素
	public void push(Object object)
	{
		ensureCapacity();
		elementData[size++] = object;
	}
	public Object pop()
	{
		if(size == 0)
		{
			throw new RuntimeException("空棧異常");
		}
		return elementData[--size];
	}
	public int size()
	{
		return size;
	}
	//保證底層數組能容納棧內所有元素
	private void ensureCapacity()
	{ //增加堆棧的容量
		if(elementData.length==size)
		{
			Object[] oldElements = elementData;
			int newLength = 0;
			//已經設置capacityIncrement
			if (capacityIncrement > 0)
			{
				newLength = elementData.length + capacityIncrement;
			}
			else
			{
				//將長度擴充到原來的1.5倍
				newLength = (int)(elementData.length * 1.5);
			}
			elementData = new Object[newLength];
			//將原數組的元素複製到新數組中
			System.arraycopy(oldElements , 0 , elementData , 0 , size);
		}
	}
	public static void main(String[] args)
	{
		Stack stack = new Stack(10);
		//向棧頂壓入10個元素
		for (int i = 0 ; i < 10 ; i++)
		{
			stack.push("元素" + i);
			System.out.println("元素" + i+"入棧");
		}
		//依次彈出10個元素
		for (int i = 0 ; i < 10 ; i++)
		{
			System.out.println(stack.pop()+"出棧");
		}
	}
}

運行結果：

元素0入棧
元素1入棧
元素2入棧
元素3入棧
元素4入棧
元素5入棧
元素6入棧
元素7入棧
元素8入棧
元素9入棧
元素9出棧
元素8出棧
元素7出棧
元素6出棧
元素5出棧
元素4出棧
元素3出棧
元素2出棧
元素1出棧
元素0出棧

[color=red]2.棧的鏈式存儲實現：[/color]

public class LinkStack<T>
{
	//定義一個內部類Node，Node實例代表鏈棧的節點。
	private class Node
	{
		//保存節點的數據
		private T data;
		//指向下個節點的引用
		private Node next;
		//無參數的構造器
		public Node()
		{
		}
		//初始化全部屬性的構造器
		public Node(T data , Node next)
		{
			this.data = data;
			this.next = next;
		}
	}
	//保存該鏈棧的棧頂元素
	private Node top;
	//保存該鏈棧中已包含的節點數
	private int size;
	//創建空鏈棧
	public LinkStack()
	{
		//空鏈棧，top的值爲null
		top = null;
	}
	//以指定數據元素來創建鏈棧，該鏈棧只有一個元素
	public LinkStack(T element)
	{
		top = new Node(element , null);
		size++;
	}
	//返回鏈棧的長度	
	public int length()
	{
		return size;
	}
	//進棧
	public void push(T element)
	{
		//讓top指向新創建的元素，新元素的next引用指向原來的棧頂元素
		top = new Node(element , top);
		size++;
	}
	//出棧
    public T pop()
	{
		Node oldTop = top;
		//讓top引用指向原棧頂元素的下一個元素
		top = top.next;
		//釋放原棧頂元素的next引用
		oldTop.next = null;
		size--;
		return oldTop.data;
	}
	//訪問棧頂元素，但不刪除棧頂元素
	public T peek()
	{
		return top.data;
	}
	//判斷鏈棧是否爲空棧
	public boolean empty()
	{
		return size == 0;
	}
	//清空鏈棧
	public void clear()
	{
		//將底層數組所有元素賦爲null
		top = null;
		size = 0;
	}
	public String toString()
	{
		//鏈棧爲空鏈棧時
		if (empty())
		{
			return "[]";
		}
		else
		{
			StringBuilder sb = new StringBuilder("[");
			for (Node current = top ; current != null
				; current = current.next )
			{
				sb.append(current.data.toString() + ", ");
			}
			int len = sb.length();
			return sb.delete(len - 2 , len).append("]").toString();
		}
	}
}

java集合提供了兩種棧供開發者使用：
java.util.Stack:一個普通的順序棧，底層基於數組實現。這個Stack類是線程安全的。
java.util.LinkedList:是一個雙向鏈表。線程不安全，可以當做棧來使用，提供了push(),pop(),peek()等方法。在多線程環境下使用，可以使用Collections類的工具方法將其改造成線程安全類。