顺序存储列表之栈

顺序存储列表之 栈

• 概念

首先栈是一种“先进后出”或者"后进先出"的一种数据结构，它是一个有序集合，其中添加和删除元素都是发生在同一端，通常称作发生操作的这一端为顶部，对应的端为底部。它的底层是数组实现的。
比如你卖菜收摊的时候，放在菜筐最底下的蔬菜，第二天最后一个拿出来，这就体现了一个先进后出/后进先出的原则。

• 实现
  首先定义栈的接口方法
  
  上图为stack栈接口的方法

package com.snow.栈;
/**
 * Stack是栈的接口
 * 
 * */
public interface Stack<E> {
	/**
	 * 获取栈中元素的个数
	 * @return 栈中的元素个数
	 * */
	public int getSize();
	
	/**
	 * 判断当前栈是否为空
	 * @return 是否为空布尔值
	 * */
	public boolean isEmpty();
	/**
	 * 进栈一个元素e
	 * @param e 即将进栈的元素
	 * */
	public void push(E e);
	
	/**
	 * 出栈一个元素
	 * @return 当前出栈的栈顶元素
	 * */
	public E pop();
	
	/**
	 * 获取当前栈顶元素
	 * @return 当前栈顶的元素 不弹栈
	 * */
	public E peek();
	
	/**
	 * 清空栈
	 * */
	public void clear();
}

查阅API发现，Stack接口下，ArrayStack是它的子类，底层是用数组实现的，好了，下图为它的方法（注意这里要用到的ArrayList是上一篇我们自己实现的Ar’rayList，而不是util下面的，之一导包不要导错）。

代码实现：

package com.snow.栈;

import com.snow.线性表.ArrayList;


public class ArrayStack<E> implements Stack<E> {
 
	private ArrayList<E> list;
	
	/**
	 * 创建默认大小的栈
	 */
    public ArrayStack() {
		list = new ArrayList<E>();
	}
    
    /**
         * 创建指定容量大小的栈
     * @param capacity
     */
    public ArrayStack(int capacity) {
    	list = new ArrayList<E>(capacity);
    }
    
	@Override
	public int getSize() {  //获取当前存储元素的个数
		return list.getSize();  //调用List内置方法，获取当前有效的元素个数
	}
 
	@Override
	public boolean isEmpty() {  //判空
		return list.isEmpty();
	}
 
	@Override
	public void push(E e) {  //压栈，进栈是从尾部进栈
		list.addLast(e); //List的尾部添加方法
	}
	@Override
	public E pop() {   //弹栈，删除尾部的元素
		return list.removeLast(); //调用List的尾部删除方法
	}
 
	@Override
	public E peek() {  //获取栈顶元素，就是获取尾部元素，只访问，不删除
		return list.getLast();
	}
 
	@Override
	public void clear() { //清空栈，栈顶指针回到栈尾，尾指针回到数组头部
		list.clear();
	}
	
    @Override
    public boolean equals(Object obj) {   //这里是栈的equals方法，这里重写的是object中的equals方法。比的是栈，但是这个顺序栈是用顺序表实现的
	if(obj==null) {
		return false;
	}
	if(obj==this) {
		return true;
	}
	if(obj instanceof ArrayStack) {
		ArrayStack stack = (ArrayStack) obj; //强转成内部栈对象
		return list.equals(stack.list);//栈内当前的list对象与传进来的栈对象调用的内部的list对象做比较
	}
	return false;
	}
    
    @Override
    public String toString() { 
    	StringBuilder sb = new StringBuilder();
    	
    	sb.append("ArrayStack:size="+getSize()+",capaicty="+list.getCapacity()+"\n");
    	if(isEmpty()) {
			sb.append("[]");
		}else {
			sb.append('[');
			for(int i=0;i<getSize();i++) {
				sb.append(list.get(i));
				if(i==getSize()-1) {
					sb.append(']');
				}else {
					sb.append(',');
				}
			}
		}
		return sb.toString();
	}
}

栈的进出只在指定的一个端口，如果你想两边都能操作呢？这里就出来了一个双端栈。

• 双端栈
  双端栈就是将一个栈的两端当做栈底进行入栈和出栈操作。什么意思呢？就是把一个竖着的栈放倒后，左右两边当作栈底，那么它的左右两边都可以进行入出栈操作。
  
  两边操作确实方便了许多，但是问题来了，如果你进栈和出栈，那么应该从哪进？往哪出呢？还有就是进栈的时候是往哪边进？操作方便了，但是它所定义的方法就复杂了许多，那么这一问题如何解决呢？我们可以使用枚举方法，定义左右两个变量，enum Direction{LEFT,RIGHT;}就可以了，具体我们看代码实现。

package com.snow.栈;

import com.snow.线性表.ArrayList; //我们自己写的ArrayList类

public class ArrayStackDoubleEnd<E> implements Stack<E>{
	
	enum Direction{ //enum类定义LEFT,RIGHT;两个方向变量
		LEFT,RIGHT;
	}
	
	private E[] data;            //存储数据的容器
	private int leftTop;	     //左端栈的栈顶 
	private int rightTop;	    //右端栈的栈顶 
	private static int DEFAULT_SIZE=10;	//默认容量大小为10
	/**
         *默认容量
         */
	public ArrayStackDoubleEnd(){
		this(DEFAULT_SIZE);
	}
        /**
         *指定容量
         */
	public ArrayStackDoubleEnd(int capacity){
		data=(E[]) new Object[capacity];
		leftTop=-1;//左指针在数组的头前
		rightTop=data.length; //右指针 开始在数组长度末端data.length
	}
	private boolean isFull(){  //判满
		return leftTop+1==rightTop; //当左右指针相遇
	}
	/**
	 * 向指定的端口进栈元素
	 * */
	public void push(Direction dir,E e){
		if(isFull()){                       //push判满
			resize(data.length*2);  //满>>扩容
		}
		if(dir==Direction.LEFT){ //else进栈，判断其进栈方向
			data[++leftTop]=e;  //左边栈顶添加
		}else{
			data[--rightTop]=e;  //右边栈顶添加
		}
	}
	
	
	private void resize(int newLen) {   //扩容
		E[] newData=(E[]) new Object[newLen]; //定义新数组
		//左端复制
		for(int i=0;i<=leftTop;i++){
			newData[i]=data[i];
		}
		//右端复制
		int index=data.length-1;
		int i；//i是新数组插入元素的下标
		for(i=newData.length-1;i>=newData.length-data.length+rightTop;i--){
		//用新数组的长度减去旧数组的长度再加右栈顶的位置
		//旧数组长度减去右栈顶的位置就是右边栈的有效元素的个数
		 //再用新数组的长度减去有效元素的个数就是扩容或者缩容后右栈顶的位置
			newData[i]=data[index--];
		}
		rightTop=i+1;
		data=newData; //旧数组替换成新数组
	}
	/**
	 * 从指定的端口出栈元素
	 * */
	public E pop(Direction dir){  //传入枚举类型变量
		if(dir==Direction.LEFT){  //为左
			if(leftTop==-1){ //判空
				throw new IllegalArgumentException("左端栈为空!");
			}
			E e=data[leftTop--]; //把出栈的元素取出来
			if(getSize()<=data.length/4&&data.length>DEFAULT_SIZE){
				resize(data.length/2); //缩容 --->>扩1/2
			}
			return e; //返回出栈元素
		}else{
			if(rightTop==data.length){  //与左边出栈方式一致
				throw new IllegalArgumentException("右端栈为空!");
			}
			E e=data[rightTop++];
			if(getSize()<=data.length/4&&data.length>DEFAULT_SIZE){
				resize(data.length/2);
			}
			return e;
		}
		
	}
	
	/**
	 * 从指定的端口获取栈顶元素
	 * */
	public E peek(Direction dir){
		if(dir==Direction.LEFT){ //判空
			if(leftTop==-1){
				throw new IllegalArgumentException("左端栈为空!");
			}
			return data[leftTop]; //获取的元素直接返回就行
		}else{
			if(rightTop==data.length){
				throw new IllegalArgumentException("右端栈为空!");
			}
			return data[rightTop];
		}
	}
	
	/**
	 * 获取指定端口栈的元素个数
	 * */
	public int getSize(Direction dir){
		if(dir==Direction.LEFT){
			return leftTop+1;
		}else{
			return data.length-rightTop;
		}
	}
	
	/**
	 * 判断指定端口的栈是否为空
	 * */
	public boolean isEmpty(Direction dir){
		if(dir==Direction.LEFT){
			return leftTop==-1; //左端为空在数组头前size-1位置
		}else{
			return rightTop==data.length; //右端为空在数组末尾后面
		}
	}
	/**
	 * 清空指定端口的栈
	 * */
	public void clear(Direction dir){
		if(dir==Direction.LEFT){
			leftTop=-1;  //初始化
		}else{
			rightTop=data.length;
		}
	}
	
	/**
	 * 获取左端栈和右端栈元素的总和
	 * */
	@Override
	public int getSize() { //直接调用获取指定位置元素的方法，左右相加
		return getSize(Direction.LEFT)+getSize(Direction.RIGHT);
	}
	
	/**
	 * 判断左端栈和右端栈是否全为空
	 * */
	@Override
	public boolean isEmpty() {  //判断的是整个栈是否为空
		return isEmpty(Direction.LEFT)&&isEmpty(Direction.RIGHT);
	}
	
	/**
	 * 哪端少进哪端
	 * */
	@Override
	public void push(E e) {  //不指定方向进栈一个元素
		if(getSize(Direction.LEFT)<=getSize(Direction.RIGHT)){
			push(Direction.LEFT,e);//小于进左
		}else{
			push(Direction.RIGHT,e);//大于进右
		}
	}
	
	/**
	 * 哪端多弹哪端
	 * */
	@Override
	public E pop() {  //不指定方向弹出一个元素
		if(isEmpty()){ //判空
			throw new IllegalArgumentException("双端栈为空!");
		}
		if(getSize(Direction.LEFT)>getSize(Direction.RIGHT)){
			return pop(Direction.LEFT);//左多弹左
		}else{
			return pop(Direction.RIGHT);//反之弹右
		}
	}
	
	/**
	 * 哪端多获取哪端  一样多默认左端
	 * */
	@Override
	public E peek() {
		if(isEmpty()){
			throw new IllegalArgumentException("双端栈为空!");
		}
		if(getSize(Direction.LEFT)>getSize(Direction.RIGHT)){
			return peek(Direction.LEFT);
		}else{
			return peek(Direction.RIGHT);
		}
	}
	
	/**
	 * 左右两端都清空
	 * */
	@Override
	public void clear() {  //调用代参的clear方法
		clear(Direction.LEFT);
		clear(Direction.RIGHT);
	}
	
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append("ArrayStackDoubleEnd:size="+getSize()+",capacity="+data.length+"\n");
		if(isEmpty()){
			sb.append("[]");
		}else{
			sb.append('[');
			int count=0;
			for(int i=0;i<=leftTop;i++){
				sb.append(data[i]);
				count++;
				if(count==getSize()){
					sb.append(']');
				}else{
 					sb.append(',');
 				}
			}
			for(int i=rightTop;i<data.length;i++){
 				sb.append(data[i]);
				count++;
				if(count==getSize()){
					sb.append(']');
				}else{
					sb.append(',');
				}
			}
		}
		return sb.toString();
	}
	
	/**
	 * 纯粹比较两个双端栈的内容
	 * */
	@Override
	public boolean equals(Object obj) {
		
		if(obj==null){  //传进来的为空则不相等
			return false;
		}
		if(obj==this){  //传进来的为自己则相等
			return true;
		}
		if(obj instanceof ArrayStackDoubleEnd){ //传进来的是双端栈的对象
			ArrayStackDoubleEnd<E> stack=(ArrayStackDoubleEnd) obj; //强转
			if(getSize()==stack.getSize()){ //先判断两双端栈总有效元素是否相等
               //相等的话要再判断两栈的存储元素是否相同
//如果左右相对应位置不同，可以先装入list中再比较
				ArrayList<E> list1=new ArrayList<E>(getSize()); 
				ArrayList<E> list2=new ArrayList<E>(getSize());
				//拼接当前栈的左部分
				for(int i=0;i<=leftTop;i++){
					list1.addLast(data[i]);
				}
				//拼接当前栈的右部分
				for(int i=rightTop;i<data.length;i++){
					list1.addLast(data[i]);
				}
				//拼接传入栈的左部分
				for(int i=0;i<=stack.leftTop;i++){
 					list2.addLast(stack.data[i]);
 				}
 				//拼接传入栈的右部分
				for(int i=stack.rightTop;i<stack.data.length;i++){
					list2.addLast(stack.data[i]);
 				}
				return list1.equals(list2);  //调用list的equals方法去比较两个顺序表的内容
 			}
		}
 		return false;
	}
}

双端栈的实现就完成了，代码量比较大，有些地方参考了原码，测试通过。自己手打完成，如有问题欢迎指出！