【数据结构】——栈 (顺序栈和基于Java的运算实现)

目录

栈

顺序存储 (顺序栈)

基本运算实现

溢出问题

栈

概述：在表的一端进行插入和删除，插入删除的一端称为栈顶(top)，另一端为栈底(bottom)，不含元素的空表称为空栈。

后进先出 (Last In First Out)，简称LIFO

图示：

 

顺序存储 (顺序栈)

概述：栈的顺序存储结构，是运算受限的线性表，用数组实现的。

• S.data[0]是栈底元素，S.data[top]是栈顶元素
• S.top<0表示空栈，S.top=StackSize-1表示栈满

当栈满时再做进栈运算必定产生空间溢出，简称"上溢"。
当栈空时再做退栈运算也将产生溢出，简称"下溢"。

基本运算实现

public class SeqStack {
    //定义栈的空间大小
    int size = 100;
    //数组data用来存放表结点
    Object[] data = new Object[size];
    //表示栈顶指针
    int top;

    //置空栈
    public void InitStack() {
        //数组下标从0开始的，空栈时将栈顶指针设为-1即可
        top = -1;
    }

    //判栈空：返回一个布尔值
    public boolean StackEmpty() {
        return top == -1;
    }

    //判栈满：返回一个布尔值
    public boolean StackFull() {
        return top == size - 1;
    }

    //进栈（入栈）
    public void Push(Object x) {
        //判断是否栈满
        if (StackFull()) {
            System.out.println("stack overflow!");
        } else {
            //栈顶指针加1
            top++;
            //将x入栈
            data[top] = x;
        }
    }

    //退栈（出栈）
    public void Pop() {
        //判断是否栈空
        if (StackEmpty()) {
            System.out.println("stack underflow!");
        } else {
            //栈顶指针减1
            top--;
        }
    }

    //遍历栈：后进先出
    public void StackShow() {
        for (int i = top; i > -1; i--) {
            System.out.println(data[i]);
        }
    }

    //取栈顶元素
    public Object GetTop() {
        //判断是否栈空
        if (StackEmpty()) {
            System.out.println("stack empty!");
            return null;
        } else return data[top];
    }
}

public class SeqStackTest {
    public static void main(String[] args) {
        //创建栈对象
        SeqStack ss = new SeqStack();

        //置空栈
        ss.InitStack();
        System.out.println("栈顶指针指向：" + ss.top);

        //判栈空
        boolean b = ss.StackEmpty();
        System.out.println("栈是否为空：" + b);

        //判栈满
        boolean b1 = ss.StackFull();
        System.out.println("栈是否已满：" + b1);
        System.out.println();

        //进栈（入栈）
        ss.Push("xx");
        ss.Push("hh");
        ss.Push("zz");
        ss.Push("kk");
        //遍历栈
        System.out.println("遍历栈：");
        ss.StackShow();
        System.out.println("栈顶指针指向：" + ss.top);
        //取栈顶元素
        Object o = ss.GetTop();
        System.out.println("栈顶元素为：" + o);
        System.out.println();

        //退栈（出栈）
        ss.Pop();
        ss.Pop();
        //遍历栈
        System.out.println("遍历栈：");
        ss.StackShow();
        System.out.println("栈顶指针指向：" + ss.top);
        //取栈顶元素
        Object o1 = ss.GetTop();
        System.out.println("栈顶元素为：" + o1);
    }
}

运行结果：

 

溢出问题

由于顺序栈必须预先分配空间，因此在应用中要考虑溢出问题。

在实际应用中还可能同时使用多个栈，为了防止溢出，需要为每一个栈分配一个较大的空间，这样往往会产生空间上的浪费，因为当某一个栈发生溢出的同时，其余的栈还可能有很多未用空间。如果将多个栈分配在同一个顺序存储空间内，即让多个栈共享存储空间，则可以相互进行调节，既节约了空间，又可降低发生溢出的频率。

当程序中同时使用两个栈时，可以将两个栈的栈底分别设在顺序存储空间的两端，让两个栈顶各自向中间延申。当一个栈中的元素较多而栈使用的空间超过共享空间的一半时，只要另一个栈中的元素不多，就可以让第一个栈占用第二个栈的部分存储空间。只有当整个存储空间被两个栈占满时 (两栈顶相遇)，才会产生溢出。

---