一文读懂栈

最新推荐文章于 2024-10-16 12:19:08 发布

小贾Coder

最新推荐文章于 2024-10-16 12:19:08 发布

阅读量671

点赞数 27

分类专栏：数据结构文章标签：数据结构 java

本文链接：https://blog.csdn.net/weixin_40586595/article/details/142346772

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

独立站原文

定义

栈是一种特殊的线性表,只可以在线性表的底部进行插入和删除操作.

线性表的头部被称为栈底,底部被成为栈顶,也就是说栈只可以在栈顶进行插入或者删除操作

插入操作被称为压栈(push)
在这里插入图片描述

删除操作被叫做弹栈(pop).
在这里插入图片描述

抽象数据类型

数据

/**
 * 栈抽象数据类型
 *
 * @param <T>
 */
public class ArrayStack<T> implements IStack<T> {
    /**
     * 栈是基于线性表来做的
     */
    protected Object[] list;
    /**
     * 栈顶
     */
    protected int top;
    /**
     * 方向 0 正向 1 负向
     */
    protected int direction;

    public ArrayStack() {
        this.init();
    }

    @Override
    public void init() {
        top = 0;
        list = new Object[100];
        direction = 0;
    }

    @Override
    public boolean destroyStack() {
        list = null;
        return true;
    }

    @Override
    public boolean clearStack() {
        if (direction == 0) {
            for (int i = 0; i <= top; i++) {
                list[i] = null;
            }
        } else if (direction == 1) {
            for (int i = list.length - 1; i >= top; i--) {
                list[i] = null;
            }
        }
        top = direction == 0 ? 0 : 99;
        return true;
    }

    @Override
    public boolean stackEmpty() {
        return list == null || (top == 0 && direction == 0) || (top == list.length - 1 && direction == 1);
    }

    @Override
    @SuppressWarnings("unchecked")
    public T getTop() {
        if (this.stackLength() == 0){
            return null;
        }
        return (T) list[direction == 0 ? top - 1 : top + 1];
    }

    @Override
    @SuppressWarnings("unchecked")
    public T pop() {
        int topIndex = direction == 0 ? top - 1 : top + 1;
        Object topObj = list[topIndex];
        list[topIndex] = null;
        if (direction == 0) {
            top--;
        } else {
            top++;
        }
        return (T) topObj;
    }

    @Override
    public void push(T e) {
        if (top + 1 > list.length || top < 0) {
            throw new OutOfRangeException("stack push error");
        }

        int next = direction == 0 ? top++ : top--;
        if (list[next] != null) {
            throw new OutOfRangeException("stack push error");
        }
        list[next] = e;
    }

    @Override
    public int stackLength() {
        return direction == 0 ? top : list.length - top - 1;
    }

    @Override
    @SuppressWarnings("unchecked")
    public List<T> getList() {
        if (null == list)return null;
        return top == 0 ? new ArrayList<>() : new ArrayList<>(Arrays.copyOf(list, top));
    }
}

行为

IStack

/**
 * 栈
 */
public interface IStack<T> {
    /**
     * 初始化
     */
    void init();

    /**
     * 销毁栈
     */
    boolean destroyStack();

    /**
     * 清空栈
     */
    boolean clearStack();

    /**
     * 栈是否为空
     *
     * @return true 空 false 非空
     */
    boolean stackEmpty();

    /**
     * 若栈非空，返回栈顶元素
     *
     * @return T
     */
    T getTop();

    /**
     * 弹栈
     *
     * @return 栈顶元素
     */
    T pop();

    /**
     * 压栈
     *
     * @param e 元素
     */
    void push(T e);

    /**
     * 返回栈长度
     *
     * @return int
     */
    int stackLength();

    /**
     * 获取栈存储list(非标准中包含该方法)
     * @return list
     */
    List<T> getList();
}

IShardedStack.java

public interface IShardedStack<T> extends IStack<T>{
    /**
     * 初始化
     */
    void init();

    /**
     * 销毁栈
     */
    void destroyStack(int num);

    /**
     * 清空栈
     */
    void clearStack(int num);

    /**
     * 栈是否为空
     *
     * @return true 空 false 非空
     */
    boolean stackEmpty(int num);

    /**
     * 若栈非空，返回栈顶元素
     *
     * @return T
     */
    T getTop(int num);

    /**
     * 弹栈
     *
     * @return 栈顶元素
     */
    T pop(int num);

    /**
     * 压栈
     *
     * @param e 元素
     */
    void push(T e,int num);

    /**
     * 返回栈长度
     *
     * @return int
     */
    int stackLength(int num);
}