Java数据结构与算法之栈(Stack)实现详解

/*
* 栈接口抽象数据类型
*/
public interface Stack<T> {

 /**
 * 栈是否为空
 * @return
 */
 boolean isEmpty();

 /**
 * data元素入栈
 * @param data
 */
 void push(T data);

 /**
 * 返回栈顶元素,未出栈
 * @return
 */
 T peek();

 /**
 * 出栈,返回栈顶元素,同时从栈中移除该元素
 * @return
 */
 T pop();
}

/* 
* 顺序栈的实现
 */
public class SeqStack<T> implements Stack<T>,Serializable {

 private static final long serialVersionUID = -5413303117698554397L;

 /**
  * 栈顶指针,-1代表空栈
  */
 private int top=-1;

 /**
  * 容量大小默认为10
  */
 private int capacity=10;

 /**
  * 存放元素的数组
  */
 private T[] array;

 private int size;

 public SeqStack(int capacity){
  array = (T[]) new Object[capacity];
 }

 public SeqStack(){
  array= (T[]) new Object[this.capacity];
 }
 //.......省略其他代码
}

/**
 * 获取栈顶元素的值,不删除
 * @return
 */
 @Override
 public T peek() {
  if(isEmpty())
   new EmptyStackException();
  return array[top];
 }

/**
 * 添加元素,从栈顶(数组尾部)插入
 * 容量不足时，需要扩容
 * @param data
 */
@Override
public void push(T data) {
 //判断容量是否充足
 if(array.length==size)
  ensureCapacity(size*2+1);//扩容

 //从栈顶添加元素
 array[++top]=data;
 }

/**
 * 从栈顶(顺序表尾部)删除
 * @return
 */
 @Override
 public T pop() {
  if(isEmpty())
   new EmptyStackException();
  size--;
  return array[top--];
 }

import java.io.Serializable;
import java.util.EmptyStackException;

/*
 * 顺序栈的实现
 */
public class SeqStack<T> implements Stack<T>,Serializable {

 private static final long serialVersionUID = -5413303117698554397L;

 /**
  * 栈顶指针,-1代表空栈
  */
 private int top=-1;

 /**
  * 容量大小默认为10
  */
 private int capacity=10;

 /**
  * 存放元素的数组
  */
 private T[] array;

 private int size;

 public SeqStack(int capacity){
  array = (T[]) new Object[capacity];
 }

 public SeqStack(){
  array= (T[]) new Object[this.capacity];
 }

 public int size(){
  return size;
 }


 @Override
 public boolean isEmpty() {
  return this.top==-1;
 }

 /**
  * 添加元素,从栈顶(数组尾部)插入
  * @param data
  */
 @Override
 public void push(T data) {
  //判断容量是否充足
  if(array.length==size)
   ensureCapacity(size*2+1);//扩容

  //从栈顶添加元素
  array[++top]=data;

  size++;
 }

 /**
  * 获取栈顶元素的值,不删除
  * @return
  */
 @Override
 public T peek() {
  if(isEmpty())
   new EmptyStackException();
  return array[top];
 }

 /**
  * 从栈顶(顺序表尾部)删除
  * @return
  */
 @Override
 public T pop() {
  if(isEmpty())
   new EmptyStackException();
  size--;
  return array[top--];
 }

 /**
  * 扩容的方法
  * @param capacity
  */
 public void ensureCapacity(int capacity) {
  //如果需要拓展的容量比现在数组的容量还小,则无需扩容
  if (capacity<size)
   return;

  T[] old = array;
  array = (T[]) new Object[capacity];
  //复制元素
  for (int i=0; i<size ; i++)
   array[i]=old[i];
 }

 public static void main(String[] args){
  SeqStack<String> s=new SeqStack<>();
  s.push("A");
  s.push("B");
  s.push("C");
  System.out.println("size->"+s.size());
  int l=s.size();//size 在减少,必须先记录
  for (int i=0;i<l;i++){
   System.out.println("s.pop->"+s.pop());
  }

  System.out.println("s.peek->"+s.peek());
 }
}

import com.zejian.structures.LinkedList.singleLinked.Node;

import java.io.Serializable;

/*
 * 栈的链式实现
 */
public class LinkedStack<T> implements Stack<T> ,Serializable{

 private static final long serialVersionUID = 1911829302658328353L;

 private Node<T> top;

 private int size;

 public LinkedStack(){
  this.top=new Node<>();
 }

 public int size(){
  return size;
 }


 @Override
 public boolean isEmpty() {
  return top==null || top.data==null;
 }

 @Override
 public void push(T data) {
  if (data==null){
   throw new StackException("data can\'t be null");
  }
  if(this.top==null){//调用pop()后top可能为null
   this.top=new Node<>(data);
  }else if(this.top.data==null){
   this.top.data=data;
  }else {
   Node<T> p=new Node<>(data,this.top);
   top=p;//更新栈顶
  }
  size++;
 }

 @Override
 public T peek() {
  if(isEmpty()){
   throw new EmptyStackException("Stack empty");
  }

  return top.data;
 }

 @Override
 public T pop() {
  if(isEmpty()){
   throw new EmptyStackException("Stack empty");
  }

  T data=top.data;
  top=top.next;
  size--;
  return data;
 }
 //测试
 public static void main(String[] args){
  LinkedStack<String> sl=new LinkedStack<>();
  sl.push("A");
  sl.push("B");
  sl.push("C");
  int length=sl.size();
  for (int i = 0; i < length; i++) {
   System.out.println("sl.pop->"+sl.pop());
  }
 }
}