顺序栈操作

一，栈的定义

   ♦ 栈：是限定在表尾进行插入或删除操作的线性表。

   ♦对栈来说，一般将表尾称为栈顶（top)，表头端称为栈底(base)。不含元素的空表称为空栈。

   ♦ 栈的修改是按后进先出的原则进行的，因此，栈又称为后进先出的线性表。

二，栈的表示与实现

  顺序栈：即栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，

                同时附设指针top,初值指向栈底（top=0),每当插入一个新的栈顶元素指针top+1,同样的删

                除一个栈顶元素top-1，因此非空栈中，指针始终指向栈顶元素的下一 个位置。

  　　　　指针base为栈底指针，在顺序栈中，它始终指向栈底位置。

                top=0，为空栈，top=stack.length,为栈满。

    代码实现

/**
 * 顺序栈代码实现
 */
import java.util.*;
class SeqStack{
    // 存储栈元素的数组
    private int[] stack;
    // 标识栈顶的位置
    private int top;

    // 默认构造，初始大小为10
    public SeqStack() {
        /*this.stack=new int[10];   //因为该栈的底层是数组
        this.top=0;*/
        this(10);      //调用另一个构造函数
    }

    // 构造函数，用户指定栈的初始大小
    public SeqStack(int size) {
        this.stack=new int[size];   //因为该栈的底层是数组
        this.top=0;     //初始时，栈为空时，top指向stack[0]位
    }

    // 入栈操作
    public void push(int val){             //入栈前先要对栈空间进行检测
        if(this.stack.length==this.top)  //因为top指向的是所填元素的下一位，所以当top值等于stack.length值时，则栈满。
        {     //栈满，若要继续存储元素，则要先进行扩容。
            this.stack=Arrays.copyOf(this.stack,this.stack.length+1);
        }
        this.stack[top]=val;    //因为top指向的是所填元素的下一位，所以此时top位为空，直接将val存储在stack[top]位。
        this.top++;            //填完元素之后，将top指向下一位。
    }

    // 出栈，并把出栈的元素返回
    public void pop(int count){      //自定义打印长度count
        int j=this.top;
        for(int i=this.top-1;i>=(this.top-count);i--,j--)  //打印一个元素，top减1
        {
            System.out.print(this.stack[i]+" ");
        }
        this.top=j;
        System.out.println();
    }
    public int pop() {   //默认出栈一个元素

            //this.top--;
            int val=this.stack[--this.top];
            return val;

    }

        // 返回栈顶元素
    public int top(){
        if(empty()){        //先判断栈中是否有元素
            return 00000000;
        }else{
            return stack[top-1];
        }

    }

    // 判断栈空
    public boolean empty(){

       /* if(this.top==0)
        {
            return true;
            //System.out.println("栈空");
        }
        return false;*/
       return this.top==0;  //返回Boolean型值
    }

    // 判断栈满
    public boolean full(){
        /*if(this.top==this.stack.length)
        {
            return true;
        }
        return false;*/
        return this.top==this.stack.length;  //返回Boolean型值
    }

    // 返回栈元素的个数
    public int size(){
        return this.top;   //因为top指向栈顶元素下一位，且元素是从0位开始存储的
    }

    // 自定义栈元素的打印方式
    //@Override
    public String toString(int[] arr) {
        String str=new String();
        for(int i=this.top-1;i>=0;i--)  //因为当栈不为空时，top指向的始终是栈顶元素的下一位
        {
          str=str+this.stack[i]+" " ;     //用连接符的方式将数组中的数打印出来
        }
        return  str;
    }
}

/**
 * 描述: 顺序栈代码测试
 */




public class SeqStacktext {
    public static void main(String[] args) {

        SeqStack ss=new SeqStack(5);  //新new一个栈（数组），jvm自动调用构造方法。
        for(int i=0;i<5;i++)
        {
            ss.push(i+1);    //入栈操作
        }

        System.out.println(ss.top());  //打印栈顶元素

        if(ss.full())    //判断栈满
        {
            System.out.println("栈满！");
        }
        System.out.println(ss.size());
        ss.pop(5);     // 定义出栈元素个数
        if(ss.empty())    //判断栈空
        {
            System.out.println("栈空！");
        }
       // ss.pop();            //默认出栈一个元素
    }
}

运行结果：