栈
定义：栈是限定仅在表尾进行插入和删除操作的线性表。
我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。
栈是一个线性表，但它是一种特殊的线性表。定义是在线性表的表尾进行插入和删除操作，但在这里表尾是指栈顶，而不是栈底。
这中特殊就限定了这个线性表插入和删除的位置，它的操作只在栈顶进行。
这也就使得：栈的底部是固定的，最先进栈的只能在栈底。
栈的插入操作，叫做进栈，也称压栈、入栈。
栈的删除操作，叫做出栈，也叫做弹栈。
如图：
同样的我们可以对栈进行一些操作
栈的接口：
1. getSize（）；获取栈中有效元素的个数
2. isEmpty（）；判断栈是否为空
3. push（）；让数据进栈
4. pop（）；让数据出栈
5. peek（）；获取栈顶数据
6. clear（）；清空栈
接口代码
/**
* 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();
}
接下来要写实现接口的子类
在对ArrayStack进行操作的时候相当于对ArrayList进行操作，因为栈就是一种特殊的线性表。所以这里把ArrayList当做成员变量来用。
但是在线性表中没有top这个概念，所以在栈中用size-1来表示当前栈的栈顶。
代码如下：
import com.oupeng.p1线性表.ArrayList;
public class ArrayStack<E> implements Stack<E> {
//栈的实现完全可以借助于ArrayList
private ArrayList<E> list;
/**
* 创建一个默认大小的栈(顺序表)
* */
public ArrayStack(){
list=new ArrayList<E>();
}
/**
* 创建一个容量为指定capacity大小的栈(顺序表)
* */
public ArrayStack(int capacity){
list=new ArrayList<E>(capacity);
}
@Override
public int getSize() {
return list.getSize();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public void push(E e) {
list.addLast(e);
}
@Override
public E pop() {
return list.removeLast();
}
@Override
public E peek() {
return list.getLast();
}
@Override
public void clear() {
list.clear();
}
@Override
public boolean equals(Object obj) {
if(obj==null){
return false;
}
if(obj==this){
return true;
}
if(obj instanceof ArrayStack){
ArrayStack stack=(ArrayStack) obj;
return list.equals(stack.list);
}
return false;
}
@Override
public String toString() {
StringBuilder sb=new StringBuilder();
sb.append("ArrayStack: size="+getSize()+",capacity="+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();
}
}
双端栈
定义：双端栈是指将一个线性表的两端当做栈底分别进行入栈和出栈操作
如图：
相当于把两个栈放倒拼到一起，此时栈里就有两个栈顶和两个栈底。
此时是一个空的双端栈
入栈操作
两个栈顶指针从两端向中间移动
此时我们判断入栈元素的方向是哪端少进哪端
此时不然看出 lefttop+1=righttop ，表示栈已满
出栈此时的定义是哪端多从哪端出
左端出的话lefttop–；
右端出的话righttop++；
判断为空的条件是：两端都为空
获取栈顶元素的条件是：哪端多获取哪端的元素
比较两个栈则是把两个栈中的元素分别放到新数组中再进行比较
ArrayStackDoubleEnd代码如下：
import com.oupeng.p1线性表.ArrayList;
public class ArrayStackDoubleEnd<E> implements Stack<E>{
enum Direction{
LEFT,RIGHT;
}
private E[] data; //用于存储数据的容器
private int leftTop; //左端栈的栈顶 开始在-1
private int rightTop; //右端栈的栈顶 开始在data.length
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;
}
private boolean isFull(){
return leftTop+1==rightTop;
}
/**
* 向指定的端口进栈元素
* */
public void push(Direction dir,E e){
if(isFull()){
resize(data.length*2);
}
if(dir==Direction.LEFT){
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;
//6 7 8 9
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);
}
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;
}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(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()){
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);
}
}
return false;
}
}
总结：双端栈就是把两个栈拼接到一起，利用leftTop指针和rightTop指针来进行操作。
扫一扫
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
