博客

目录

1. 基本概念；

2. 设计与实现；

2.1 建立动态数组实体类SeqStack类；

2.2 再建立方法类SeqStackDao类；

2.3 测试类SeqStackMain类；

---

1. 基本概念；

栈的顺序存储结构

简称

顺序栈

，它是运算受限制的顺序表；

顺序栈的存储结构：

利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素；

同时附设指针top指示栈顶元素在顺序表中的位置；

2. 设计与实现；

栈是一种特殊的线性表，所以栈的顺序存储可以通过顺序线性表（动态数组）来实现；

2.1 建立动态数组实体类SeqStack类；

SeqStack:

包括栈的

结点数据

和

元素个数

；还有一个动态数组的最大容量，我们设置为常量；

结点数据是


Object


类型的，元素个数是


int


的；

SeqStack:

package com.java.model;

public class SeqStack {

    //动态数组的最大容量
    public final static int Max_Size=1024;

    //栈的结点数据
    public Object[] data;
    //栈的长度，用来标识数组中的元素个数
    public int size;

    //构造函数
    public SeqStack(Object[] data, int size) {
        this.data = data;
        this.size = size;
    }
}

2.2 再建立方法类SeqStackDao类；

这里面包含了一些对顺序栈操作的方法；

如：

初始化栈，入栈，出栈，查看栈顶元素，返回栈中元素个数

等；

package com.java.dao;

import com.java.model.SeqStack;

import static com.java.model.SeqStack.Max_Size;

public class SeqStackDao {

    //初始化栈
    public SeqStack Init_SeqStack(){
        //动态数组初始化，加数组容量
        Object[] data1=new Object[Max_Size];

        //栈初始化，元素个数size为0
        SeqStack stack=new SeqStack(data1,0);

        //数组赋值
        for(int i=0;i<Max_Size;i++){
            stack.data[i]=0;
        }
        return stack;
    }
    //入栈
    public void Push_SeqStack(SeqStack stack,Object data){
        if(stack==null){
            return;
        }
        if(data==null){
            return;
        }
        //如果栈容量小于或等于数组容量
        if(stack.size==Max_Size){
            return;
        }
        //元素入栈
        stack.data[stack.size]=data;
        stack.size++;
    }
    //查找栈顶元素
    public Object Top_SeqStack(SeqStack stack){
        if(stack==null){
            return null;
        }
        //若栈元素为0，则返回null
        if(stack.size==0){
            return null;
        }
        //栈顶元素，注意数组下标从0开始，所以要减1
        Object o=stack.data[stack.size-1];
        return o;
    }
    //出栈操作
    public void Pop_SeqStack(SeqStack stack){
        if(stack==null){
            return;
        }
        if(stack.size==0){
            return;
        }
        //出栈
        stack.size--;
    }
    //判断是否为空
    public boolean IsEmpty(SeqStack stack){
        if(stack==null){
            return false;
        }
        if(stack.size==0){
            return true;
        }
        return false;
    }
    //返回栈中元素的个数
    public int Size_SeqStack(SeqStack stack){
        return stack.size;
    }
    //清空栈
    public void Clear_SeqStack(SeqStack stack){
        if(stack==null){
            return;
        }
        for(int i=0;i<stack.size;i++){
            stack.data[i]=null;
        }
        stack.size=0;
    }

}

2.3 测试类SeqStackMain类；

这个主要是包含主函数，进行测试的类；

package com.java.main;

import com.java.dao.SeqStackDao;
import com.java.model.SeqStack;

public class SeqStackMain {
    public static void main(String[] args) {
        SeqStackDao seqStackDao=new SeqStackDao();
        //初始化栈
        SeqStack stack=seqStackDao.Init_SeqStack();

        //入栈
        seqStackDao.Push_SeqStack(stack,"A");
        seqStackDao.Push_SeqStack(stack,"B");
        seqStackDao.Push_SeqStack(stack,"C");
        seqStackDao.Push_SeqStack(stack,"D");
        seqStackDao.Push_SeqStack(stack,"E");

        //输出栈元素
        while(stack.size>0) {
            //查找栈顶元素
            Object o = seqStackDao.Top_SeqStack(stack);
            System.out.println(o);
            //出栈
            seqStackDao.Pop_SeqStack(stack);
        }
    }
}

测试结果：

可以看到入栈元素的顺序与出栈元素的顺序相反！

项目源码地址：

https://gitee.com/Huke-123/DataConstruct