Java实现数据结构基本算法——顺序栈

---

一、栈的定义

栈是限制在表的同一端进行插入和删除的线性表。允许插入、删除的这一端称为栈顶，另一固定端称为栈底。栈中没有元素时称为空栈，故称栈为操作受限的线性表。假如栈中有三个元素，进栈的顺序是s₁，s₂，s₃，出栈时的顺序是s₃，s₂，s₁，所以栈又被称为后进先出（Last Input First Output）或先进后出（First Input Last Output）线性表，简称LIFO表或FIFL表。
分类：栈也可以采用顺序存储和链式存储两种存储结构，顺序存储的栈称为顺序栈，链式存储的栈称为链栈。

---

二、接口的声明

public interface Stack <E>{             //栈接口
    boolean isEmpty();                  //判断是否空栈，若空栈则返回true
    boolean push(E element);            //元素element入栈，若操作成功返回true
    E pop();                            //出栈，返回当前栈顶元素，若栈空则返回null
    E get();                            //取栈顶元素，未出栈，若栈空则返回null
    int StackDeepth();                  //求栈深度
    boolean ClearStack();               //清空栈
}

---

三、类的声明

1、顺序栈类——SeqStack

public class SeqStack<E> implements Stack<E>{       //顺序栈类

    private Object value[];             //存储栈的数据元素的数组
    private int top;                    //top为栈顶元素下标
    
	 //构造指定容量的空栈
    public SeqStack(int capacity) {}
	
	//构造默认容量的空栈
    public SeqStack() {}

    //判断是否空栈，若空栈返回true
    public boolean isEmpty() {}

    //元素element入栈，若操作成功返回true
    public boolean push(E element) {}
    
    //出栈，返回当前栈顶元素，若栈空返回null
    public E pop() {}
    
    //取栈顶元素，未出栈，栈顶元素未改变
    public E get() {}
    
    //求栈的深度
    public int StackDeepth() {}
    
    //清空栈
    public boolean ClearStack() {}
}

---

四、方法的声明

1、构造指定容量的空栈

    public SeqStack(int capacity) {             //构造指定容量的空栈
        this.value = new Object[Math.abs(capacity)];
        this.top = -1;
    }

2、构造默认容量的空栈

    public SeqStack() {             //构造默认容量的空栈
        this(10);
    }

3、判断是否空栈、若空栈返回true

    public boolean isEmpty() {      //判断是否空栈，若空栈返回true
        return this.top == -1;
    }

4、元素element入栈，若操作成功返回true

    public boolean push(E element) {        //元素element入栈，若操作成功返回true
        if (element == null)
            return false;                   //空对象（null）不能入栈
        if (this.top == value.length - 1){          //若栈满，则扩充容量
            Object[] temp = this.value;
            this.value = new Object[temp.length * 2];
            for (int i = 0 ; i < temp.length ; i++){
                this.value[i] = temp[i];
            }
        }
        this.top++;
        this.value[this.top] = element;
        return true;
    }

5、出栈，返回当前栈顶元素，若栈空返回null

    public E pop() {
        if (!isEmpty())
            return (E)this.value[this.top--];
        else
            return null;
    }

6、取栈顶元素，未出栈，栈顶元素未改变

    public E get() {
        if (!isEmpty())
            return (E)this.value[this.top];
        else
            return null;
    }

7、求栈的深度

    //求栈的深度
    public int StackDeepth() {
        return this.top;
    }

8、清空栈

    //清空栈
    public boolean ClearStack() {
        this.top = 0;
        return true;
    }

---

五、栈的简单使用

1、代码实现

public class Stack_operation {
    public static void main(String args[]){
        String str = "ABCDEFG";
        String str1 = "";
        SeqStack stack = new SeqStack(str.length());
        System.out.println("入栈顺序为：");
        for (int i = 0 ; i < str.length() ; i++){
            char ch = str.charAt(i);
            stack.push(ch);
            System.out.printf("%c\t",ch);
        }
        System.out.println("\n栈深度为："+stack.StackDeepth());
        System.out.println("栈顶元素为："+stack.get());
        for(int i = 0 ; i < str.length() ; i++){
            str1 += stack.get();
            stack.pop();
            if (stack.get() == null){
                System.out.println("第"+ ( i + 1) +"次出栈操作之后,栈为空栈");
            }else{
                System.out.println("第"+ ( i + 1) +"次出栈操作之后,栈顶元素为"+stack.get());
            }
        }
        System.out.println("出栈顺序为：");
        for (int i = 0 ; i < str.length() ; i++){
            System.out.printf("%c\t",str1.charAt(i));
        }

    }
}

2、运行结果