栈的实现-----java

1、顺序栈的实现

import java.util.Arrays;
public class SequenceStack<T> {
	
	private int DEFAULT_SIZE = 10;
	
	// 保存数组的长度。
	private int capacity;
	
	// 定义当底层数组容量不够时，程序每次增加的数组长度
	private int capacityIncrement = 0;
	
	// 定义一个数组用于保存顺序栈的元素
	private Object[] elementData;
	
	// 保存顺序栈中元素的当前个数
	private int size = 0;

	// 以默认数组长度创建空顺序栈
	public SequenceStack() {
		capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];
	}

	// 以一个初始化元素来创建顺序栈
	public SequenceStack(T element) {
		this();
		elementData[0] = element;
		size++;
	}

	/**
	 * 以指定长度的数组来创建顺序栈
	 * 
	 * @param element
	 *            指定顺序栈中第一个元素
	 * @param initSize
	 *            指定顺序栈底层数组的长度
	 */
	public SequenceStack(T element, int initSize) {
		this.capacity = initSize;
		elementData = new Object[capacity];
		elementData[0] = element;
		size++;
	}

	/**
	 * 以指定长度的数组来创建顺序栈
	 * 
	 * @param element
	 *            指定顺序栈中第一个元素
	 * @param initSize
	 *            指定顺序栈底层数组的长度
	 * @param capacityIncrement
	 *            指定当顺序栈底层数组的长度不够时，底层数组每次增加的长度
	 */
	public SequenceStack(T element, int initSize, int capacityIncrement) {
		this.capacity = initSize;
		this.capacityIncrement = capacityIncrement;
		elementData = new Object[capacity];
		elementData[0] = element;
		size++;
	}

	// 获取顺序栈的大小
	public int length() {
		return size;
	}

	// 入栈
	public void push(T element) {
		ensureCapacity(size + 1);
		elementData[size++] = element;
	}

	// 很麻烦，而且性能很差
	private void ensureCapacity(int minCapacity) {
		// 如果数组的原有长度小于目前所需的长度
		if (minCapacity > capacity) {
			if (capacityIncrement > 0) {
				while (capacity < minCapacity) {
					// 不断地将capacity长度加capacityIncrement，
					// 直到capacity大于minCapacity为止
					capacity += capacityIncrement;
				}
			} else {
				// 不断地将capacity * 2，直到capacity大于minCapacity为止
				while (capacity < minCapacity) {
					capacity <<= 1;
				}
			}
			elementData = Arrays.copyOf(elementData, capacity);
		}
	}

	// 出栈
	public T pop() {
		T oldValue = (T) elementData[size - 1];
		// 释放栈顶元素
		elementData[--size] = null;
		return oldValue;
	}

	// 返回栈顶元素，但不删除栈顶元素
	public T peek() {
		return (T) elementData[size - 1];
	}

	// 判断顺序栈是否为空栈
	public boolean empty() {
		return size == 0;
	}

	// 清空顺序栈
	
	public void clear() {
		// 将底层数组所有元素赋为null
		Arrays.fill(elementData, null);
		size = 0;
	}
	
	@Override
	public String toString() {
		if (size == 0) {
			return "[]";
		} else {
			StringBuilder sb = new StringBuilder("[");
			for (int i = size - 1; i > -1; i--) {
				sb.append(elementData[i].toString() + ", ");
			}
			int len = sb.length();
			return sb.delete(len - 2, len).append("]").toString();
		}
	}
	
		public static void main(String[] args) {
			SequenceStack<String>  stack =new SequenceStack<String>();
			stack.push("aaa");
			stack.push("bbb");
			stack.push("ccc");
			stack.push("ddd");
			System.out.println(stack);
			
			System.out.println(stack.peek());
			System.out.println(stack.pop());
			System.out.println(stack.pop());
			System.out.println(stack);

		}
}

2、链栈的实现

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();
		}
	}
	
	public static void main(String[] args) {
		LinkStack<String> stack = new LinkStack<String>();
		stack.push("aaaa");
		stack.push("bbbb");
		stack.push("cccc");
		stack.push("dddd");
		System.out.println(stack);
		System.out.println(stack.peek());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack);

	}
}