数据结构之双向栈结构ArrayStackDoubleEnd实现思路

什么是双向栈结构？
将一个存储空间一分为二 分为左存储空间 和 右存储空间 根据栈数据存取规则 进行数据存取的数据结构
数据排列方式为：栈顶 和 栈尾 按照自定义方式 分别存储数据。自定义方式 你可以理解为 你想让一条数据存入左边数据就去左边，你想让数据去右边 数据就存入右边
出栈方式：左端栈 数据从右边出 右端栈从左边先出。
底层实现：数组；
双向栈结构继承了Stack。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 e

public E peek();

//清除当前栈中元素
public  void clear();

public boolean equals(Object obj);

下面说实现：

public  class ArrayStackDoubleEnd<E> implements Stack{
//因为是数组实现，所以先定义一个存储容器
private E[] data;
//因为分左右我们定义一个枚举类型，用来区分容器左右。
enum goto{
	LEFT,RIGHT;
}
//定义默认容器长度
final private static int DEFAULT_LENGTH=10;   
//定义一个记录容器长度的变量
private int  length;
//定义一个表示数据长度的变量；
private int leftSize;
private int rightSize;
//构造方法   初始化
public ArrayStackDoubleEnd(){
	data=(E[])new Object(DEFAUTL_LENGTH);
	leftSize=-1;
	rightSize=DEFAUTL_LENGTH;
}
//初始化一个
public ArrayStackDoubleEnd(int capacity){
	data=(E[])new Object(capacity);
	leftSize=-1;
	rightSize=data.length;
	
}
//获取栈数据长度
public int getSize(){
	return (leftSize+1)+(data.length-rightSize);
}
return leftSize
//判断栈是否满了
public   boolean isFull(){
return leftSize+1==rightSize;
}
//判断栈是否为空
public boolean isEmpty(){
	if(leftSize==-1&& rightSize==data.length){
			return true;
	}
	return false;
}
	//定义一个方法进行判断，数据进左边 还是右边。
	public  String  panDuan(){
		int left=leftSize+1;
		int right=data.lenght-rightSize;
		if(left<=right){
			return "left";
		}
		if(left>right){
		return "right";
		}
	return "";
	}
	//进栈一个元素e   @param e 即将进栈的元素
	public void push(E e){
	// 对是否扩容进行判断    调用resize方法
	if(leftSize+1+(data.length-rightSize)>=data.length*0.85){
		resize(data.length*2);
	}
	//进栈前需要对进哪边进行判断我们调用panduan方法  
	if(panduan==left){
			data[++leftSize]=e;
	}else{
			data[--rightSize]=e;
	}
	}
	public void resize(int newLen){
		//定义一个新数组 长度为newLen  ,这里为什么不直接用E[] data1=new E[][newLen];呢因为JVM不允许
		E[] data1=(E[])new Object[newLen];
		//遍历数组内容到新数组中去
		先赋值左边
		for(int i=0;i<leftSize+1;i++){
			data1[i]=data[i];
	}
	//赋值右边
	int k=data1.lenght;
	for(int i=data.length;i>=rightSize;i--){
			data1[k]=data[i];
			k--;
	}
	data=data1;
	}
	
   //出栈一个元素   @return 当前出栈的栈顶元素
	public E pop(){
	//判断栈是否为空
	if(isEmpty){
		throw new IllegalAccessError("栈为空");
	}
	//判断是否需要缩容
	if(getSize()<=data.length/4&&data.length>DEFAULT_SIZE)
		resize(data.length/2);
		//哪边数据多就弹出去一个数据
		if(panDuan()=="left"){
				//返回左边则弹右边数据
				return data[rightSize];
		}else{
				return data[leftSize]
		}
	}

	//获取当前栈顶元素  @return e
	public E peek(fangxing fx){
		if(isEmpty){
		throw new IllegalAccessError("栈为空");
     	}
     	if(fx=="left"){
				//返回左边则弹右边数据
				return data[leftSize];
		}else  if(fx=="right"){
				//返回左边则弹右边数据
				return data[rightSize];
		}else{
				throw new Excpetion("无效输入");
		}
		return "";
	}
	
	//清除当前栈中元素
	public  void clear(){
			leftSize==-1;
			rightSize==data.lenght;
	}

//纯手打没有经过测试，如果不对欢迎批评指正。