两栈共享空间结构
本质就是两个ArrayStack尾部相接
top1为左栈栈顶 开始于-1 = leftTop
top2为右栈栈顶 开始于data.lenght = rightTop
构造方法
public class ArrayListDoubleEnd<E> implements Stack<E> {
enum Direction{ //定义枚举类型 左右
LEFT,RIGHT;
}
private E[] data;
private int leftTop; //左端栈的栈顶,开始在-1
private int rightTop; //右端栈顶,开始在data.lenght
private static int DEFAULT_SIZE = 10; //默认容量10
public ArrayListDoubleEnd() {
this(DEFAULT_SIZE); //调用有参构造
}
public ArrayListDoubleEnd(int capaticy) {
data = (E[]) new Object[capaticy];
leftTop = -1;
rightTop = data.length;
}
getSize()方法的实现
指定端元素个数 getSize(Direction dir)
public int getSize(Direction dir){
if(dir==Direction.LEFT){
return leftTop+1;
}else{
return data.length-rightTop;
}
}
元素总数
public int getSize() {
return getSize(Direction.LEFT)+getSize(Direction.RIGHT);
}
判断是否为空 isEmpty()
/**
* 判断左右端是否全为空
* @return Boolean
*/
public boolean isEmpty() {
return isEmpty(Direction.LEFT)&&isEmpty(Direction.RIGHT);
}
//指定端是否为空
public boolean isEmpty(Direction dir) {
if(dir==Direction.LEFT){
return leftTop==-1;
}else{
return rightTop==data.length;
}
}
判断是否容量满
//判断是否满
public boolean isFull(){
return leftTop+1==rightTop;
}
压栈过程
/**
* 那端少进那端
*/
public void push(E e) {
if(getSize(Direction.LEFT)>getSize(Direction.RIGHT)){
push(Direction.RIGHT,e);
}else{
push(Direction.LEFT, e);
}
}
/**
* 指定端进栈
* @param dir 指定端
* @param e 元素
*/
public void push(Direction dir,E e){
if(isFull()){
resize(data.length*2);
}
if(dir==Direction.LEFT){
data[++leftTop] = e; //指针先右移再进行入栈
}else{
data[--rightTop] = e; //指针先左移再入栈
}
}
容量更新过程 resize()
private void resize(int newLen) {
E [] newdata = (E[]) new Object [newLen];
//复制左边
for (int i=0;i<=leftTop;i++){
newdata[i] = data[i];
}
//复制右边
/*
* 创建两个标记位
* index 旧表最后一位元素所在位置
* i 新表最后一位元素所在位置
* data.length-rightTop 为旧表元素个数
* 新表长度-元素个数就是右指针的位置
* 指针位置向左移1及跳出循环
*/
int i;
int index = data.length-1;
for (i=newdata.length-1;i>=newdata.length-(data.length-rightTop);i--){
newdata[i] = data[index--];
}
rightTop = i+1; //循环跳出时i在右指针前一位,也就是左边一位
data = newdata //更新数组
}
弹栈过程 pop()
/**
* 那端多弹那端
*/
public E pop() {
if(isEmpty()){
throw new IllegalArgumentException("两端栈都为空");
}
if(getSize(Direction.LEFT)>=getSize(Direction.RIGHT)){
return pop(Direction.LEFT);
}else{
return pop(Direction.RIGHT);
}
}
/**
* 指定端出
* @param dir
* @return e
*/
public E pop(Direction dir) {
if(dir==Direction.LEFT){
if(leftTop==-1){
throw new IllegalArgumentException("左端栈为空");
}
E e = data[leftTop--]; //先取出再移动
//缩容
if(data.length>DEFAULT_SIZE&&getSize()<=data.length/4){
//长度不能小于默认长度,元素个数小于长度1/4
resize(data.length/2); //缩1/2
}
return e;
}else{
if(rightTop==data.length){
throw new IllegalArgumentException("右端栈为空");
}
E e = data[rightTop++];
//缩容
if(data.length>DEFAULT_SIZE&&getSize()<=data.length/4){
resize(data.length/2);
}
return e;
}
}
获取栈顶元素(不出栈)peek()
/**
* 获取栈顶元素,多得一端,不出栈
*/
public E peek() {
if(isEmpty()){
throw new IllegalArgumentException("两端栈为空");
}
if(getSize(Direction.LEFT)>=getSize(Direction.RIGHT)){
return peek(Direction.LEFT);
}else{
return peek(Direction.RIGHT);
}
}
/**
* 取指定端
* @param dir
* @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]; //不出栈,指针位置没有变化
}
}
清空栈 clear()
/**
* 同时清空
*/
public void clear() {
clear(Direction.LEFT);
clear(Direction.RIGHT);
}
public void clear(Direction dir){
if(dir==Direction.LEFT){
leftTop = -1; //置为初始值
}else{
rightTop = data.length;
}
}
equals()的重写
@Override
public boolean equals(Object obj) {
if(obj==null){
return false;
}
if(obj==this.data){
return true;
}
if(obj instanceof ArrayListDoubleEnd){
ArrayListDoubleEnd<E> doubleEnd = (ArrayListDoubleEnd<E>) obj;
if(doubleEnd.getSize()==getSize()){
//创建两个线性表用来存储自身与传入的obj中有效元素
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<=doubleEnd.leftTop;i++){
list2.addLast(doubleEnd.data[i]);
}
//拼接传入栈的右边
for(int i=doubleEnd.rightTop;i<doubleEnd.data.length;i++){
list2.addLast(doubleEnd.data[i]);
}
return list1.equals(list2);
}
}
return false;
}
toString()的重写
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("ArrayListDoubleEnd size="+getSize()+",capacity ="+data.length+"\n");
if(getSize()==0){
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();
}