顺序栈(Sequential Stack)

最新推荐文章于 2022-07-16 10:06:06 发布
最新推荐文章于 2022-07-16 10:06:06 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： C++数据结构 文章标签： 数据结构 后进先出的线性表 栈 顺序栈 一维数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cainv89/article/details/51388296
版权

顺序栈(Sequential Stack)

1. 顺序栈的概念

1.1 顺序栈的定义
  • 顺序栈是基于一维数组的存储表示实现的栈。
1.2 顺序栈中各元素的逻辑及存储关系
  • 顺序栈可以采用顺序表作为其存储表示，因此，可以在顺序栈的声明中用顺序表定义它的存储空间。
  • 顺序栈可以使用一维数组作为栈的存储空间，存放栈元素的数组的头指针为*elements，该数组的最大允许存放元素个数为maxSize，当前栈顶位置由数组下标指针top指示，如果栈不为空时elements[0]是栈中第一个元素。

2. 顺序栈的实现

2.1 顺序栈的类定义及其操作的实现

  • 文件：SeqStack.h

    
#ifndef SEQ_STACK_H_


#define SEQ_STACK_H_



#include "Stack.h"


#include <iostream>


#include <string>


#include <strstream>


using namespace std;

const int defaultSize = 50;
const int stackIncreament = 20;

template <class T>
class SeqStack : public Stack<T>
{
public:
    SeqStack(int sz = defaultSize);     //构造函数
    virtual ~SeqStack();                //析构函数
public:
    virtual void Push(const T& x) ;     //新元素x进栈
    virtual bool Pop(T& x);             //栈顶元素出栈，并将该元素的值保存至x
    virtual bool getTop(T& x) const;    //读取栈顶元素，并将该元素的值保存至x
    virtual bool IsEmpty() const;       //判断栈是否为空
    virtual bool IsFull() const;        //判断栈是否为满
    virtual int getSize() const;        //计算栈中元素个数
    virtual void MakeEmpty();           //清空栈的内容
public:
    template <class T>
    friend ostream& operator<<(ostream& os, const SeqStack<T>& s);  //输出栈中元素的重载操作<<
private:
    void overflowProcess();             //栈的溢出处理
private:
    T *elements;    //存放栈中元素的栈数组
    int top;        //栈顶指针
    int maxSize;    //栈最大可容纳元素个数
};

//构造函数
template <class T>
SeqStack<T>::SeqStack(int sz)
{
    cout << "$ 执行构造函数" << endl;
    if (sz >= 0)
    {
        maxSize = sz;           
        top = -1;           
        elements = new T[maxSize];
    }
}                       

//析构函数
template <class T>
SeqStack<T>::~SeqStack()
{
    cout << "$ 执行析构函数" << endl;
    delete[] elements;
    elements = NULL;
}   

//新元素x进栈
template <class T>
void SeqStack<T>::Push(const T& x)
{
    if (true == IsFull())
    {
        overflowProcess();
    }
    elements[++top] = x;
}

//栈顶元素出栈，并将该元素的值保存至x
template <class T>
bool SeqStack<T>::Pop(T& x)
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = elements[top--];
    return true;
}

//读取栈顶元素，并将该元素的值保存至x
template <class T>
bool SeqStack<T>::getTop(T& x) const
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = elements[top];
    return true;
}

//判断栈是否为空
template <class T>
bool SeqStack<T>::IsEmpty() const
{
    return (-1 == top) ? true : false;
}

//判断栈是否为满
template <class T>
bool SeqStack<T>::IsFull() const
{
    return (maxSize - 1 == top) ? true : false;
}

//计算栈中元素个数
template <class T>
int SeqStack<T>::getSize() const
{
    return top + 1;
}

//清空栈的内容
template <class T>
void SeqStack<T>::MakeEmpty()
{
    delete[] elements;
    top = -1;
    elements = new T[maxSize];
}

//输出栈中元素的重载操作<<
template <class T>
ostream& operator<<(ostream& os, const SeqStack<T>& s)
{
    os << "top=" << s.top << endl;  //输出栈顶位置
    for (int i = 0; i <= s.top; i++)
    {
        os << "[" << i << "]" << " : " << s.elements[i] << endl;
    }
    return os;
}

//栈的溢出处理
template <class T>
void SeqStack<T>::overflowProcess()
{
    cout << "$ 执行栈的溢出处理函数" << endl;
    int newSize = maxSize + stackIncreament;
    T *newelements = new T[newSize];
    for (int i = 0; i <= top; i++)
    {
        newelements[i] = elements[i];
    }
    delete[] elements;
    elements = newelements;
    maxSize = newSize;
}


#endif /* SEQ_STACK_H_ */
2.2 主函数(main函数)的实现

  • 文件：main.cpp

    
#include "SeqStack.h"



#define EXIT 0              //退出


#define PUSH 1              //新元素x进栈


#define POP  2              //栈顶元素出栈，并将该元素的值保存至x


#define GETTOP 3            //读取栈顶元素，并将该元素的值保存至x


#define ISEMPTY  4          //判断栈是否为空


#define ISFULL 5            //判断栈是否为满


#define GETSIZE 6           //计算栈中元素个数


#define MAKEEMPTY 7         //清空栈的内容


#define OPERATOR_OSTREAM 8  //输出栈中元素的重载操作<<


void print_description()
{
    cout << "------------------------------>顺序栈<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 新元素x进栈" << endl;
    cout << "#2： 栈顶元素出栈，并将该元素的值保存至x" << endl;
    cout << "#3： 读取栈顶元素，并将该元素的值保存至x" << endl;
    cout << "#4： 判断栈是否为空" << endl;
    cout << "#5： 判断栈是否为满" << endl;
    cout << "#6： 计算栈中元素个数" << endl;
    cout << "#7： 清空栈的内容" << endl;
    cout << "#8： 输出栈中元素的重载操作<<" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//判断输入的字符串每个字符是否都是数值0~9
bool IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < '0') || (s_num[i] > '9'))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return StrToTtype<T>(s_data);
}

//输入数组的最大长度
template <class T>
int get_maxsize()
{
    cout << "> 请输入数组的最大长度，maxsize = ";
    string s_maxsize;
    cin >> s_maxsize;
    while (false == IsNumber(s_maxsize))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_maxsize;
    }
    return atoi(s_maxsize.c_str());
}

//构造顺序栈
template <class T>
SeqStack<T>* construct_seqstack()
{
    cout << "\n==> 创建顺序栈" << endl;
    int n_maxsize = get_maxsize<T>();
    SeqStack<T> *seqStack = new SeqStack<T>(n_maxsize);
    return seqStack;
}

//析构顺序栈
template <class T>
void destory_seqstack(SeqStack<T>* seqStack)
{
    cout << "\n==> 释放顺序栈在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete seqStack;
    seqStack = NULL;
}

//新元素x进栈
template <class T>              
void push(SeqStack<T>* seqStack)
{
    cout << "$ 执行新元素x进栈函数" << endl;
    T data = get_data<T>();
    seqStack->Push(data);
    cout << "* 进栈成功，data = " << data << endl;
}

//栈顶元素出栈，并将该元素的值保存至x
template <class T>  
void pop(SeqStack<T>* seqStack)
{
    cout << "$ 执行栈顶元素出栈并将该元素的值保存至x函数" << endl;
    T data;
    if (false == seqStack->Pop(data))
    {
        cout << "* 出栈失败" << endl;
        return;
    }
    cout << "* 出栈成功，data = " << data << endl;
}

//读取栈顶元素，并将该元素的值保存至x
template <class T>  
void gettop(SeqStack<T>* seqStack)
{
    cout << "$ 执行读取栈顶元素并将该元素的值保存至x函数" << endl;
    T data;
    if (false == seqStack->getTop(data))
    {
        cout << "* 读取栈顶元素失败" << endl;
        return;
    }
    cout << "* 读取栈顶元素成功，data = " << data << endl;
}

//判断栈是否为空
template <class T>  
void isempty(SeqStack<T>* seqStack)
{
    cout << "$ 执行判断栈是否为空函数，IsEmpty = " << seqStack->IsEmpty() << endl;
}

//判断栈是否为满
template <class T>  
void isfull(SeqStack<T>* seqStack)
{
    cout << "$ 执行判断栈是否为满函数，IsFull = " << seqStack->IsFull() << endl;
}

//计算栈中元素个数
template <class T>  
void getsize(SeqStack<T>* seqStack)
{
    cout << "$ 执行计算栈中元素个数函数，Size = " << seqStack->getSize() << endl;
}

//清空栈的内容
template <class T>  
void makeempty(SeqStack<T>* seqStack)
{
    cout << "$ 执行清空栈的内容函数" << endl;
    seqStack->MakeEmpty();
}

//输出栈中元素的重载操作<<
template <class T>  
void operator_ostream(SeqStack<T>* seqStack)
{
    cout << "$ 执行输出栈中元素的重载操作<<函数" << endl;
    cout << *seqStack;//或operator<<(cout, *seqStack);
}

//顺序栈操作选择
template <class T>
void select_operation(SeqStack<T>* seqStack)
{
    if (NULL == seqStack)
    {
        cout << "* 没有构造顺序栈，请先构造顺序栈。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
            case EXIT://退出
            {
                cout << "$ 退出程序" << endl;
                break;
            }
            case PUSH://新元素x进栈
            {
                push(seqStack);
                break;
            }
            case POP://栈顶元素出栈，并将该元素的值保存至x
            {
                pop(seqStack);
                break;
            }
            case GETTOP://读取栈顶元素，并将该元素的值保存至x
            {
                gettop(seqStack);
                break;
            }
            case ISEMPTY://判断栈是否为空
            {
                isempty(seqStack);
                break;
            }
            case ISFULL://判断栈是否为满
            {
                isfull(seqStack);
                break;
            }
            case GETSIZE://计算栈中元素个数
            {
                getsize(seqStack);
                break;
            }
            case MAKEEMPTY://清空栈的内容
            {
                makeempty(seqStack);
                break;
            }
            case OPERATOR_OSTREAM://输出栈中元素的重载操作<<
            {
                operator_ostream(seqStack);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    SeqStack<int> *seqStack = construct_seqstack<int>();
    select_operation(seqStack);
    destory_seqstack(seqStack);
    system("pause");
    return 0;
}

参考文献：
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第三章
[2]《C/C++常用算法手册》秦姣华、向旭宇——第二章
[3] 百度搜索关键字：顺序栈

Cainv89
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言通过使用数据结构来实现双向顺序栈
12-27
双向顺序栈（Double-ended sequential stack）是一种栈数据结构，它允许在两个方向上进行入栈和出栈操作。与常规栈不同，双向顺序栈具有两个栈顶位置，一个在栈的一端，称为"头栈顶"（head），另一个在栈的另一端，...
顺序栈SeqStack的定义及其相关功能实现
qq_43627093的博客
07-29 907
定义了一个简单的顺序栈并实现几个基本功能
SeqStack
QS9816
04-29 3263
栈的顺序存储结构简称为顺序栈,它是运算受限的顺序表。1、 顺序栈的类型定义   #define StackSize 100 //假定预分配的栈空间最多为100个元素   typedef char DataType;//假定栈元素的数据类型为字符   typedef struct{       DataType data[StackSize];       int top;      }
C语言丨栈（一）：顺序栈
weixin_60921752的博客
02-09 3514
栈是限定仅在表尾进行插入或删除操作的线性表，表尾称为栈顶（top），表头称为栈底（bottom）。栈的最主要特点就是“先进后出”（FILO），或“后进先出”（LIFO）。本文在介绍栈的基本概念的基础上，重点介绍栈的顺序表示及相应的算法。
数据结构(java版)Stack(栈)SeqStack(顺序栈)LinkedStack(链式栈)
qq_41997592的博客
11-19 906
Stack(栈) public interface Stack<T> { boolean isEmpty(); void push(T var1); T peek(); T pop(); } SeqStack(顺序栈) public final class SeqStack<T> implements Stack<T> { private final SeqList<T> list; public
【数据结构】静态顺序栈的实现（附带详细注释）
weixin_65334260的博客
07-16 666
栈这种特殊的存储结构用途十分广泛，本篇采用静态一维数组实现了这种特殊的存储结构并同时实现了对它的一些简单操作。
c语言数组模拟栈和队列,简单用数组模拟顺序栈（c++）
weixin_29150151的博客
05-24 767
**栈是一种操作受限制的线性表，太多官方的话我也不说了，我们都知道栈元素是先进后出的，它有两种存储结构，分别是顺序存储结构和链式存储结构。**今天我先记一下顺序存储结构，后面我会加上链式存储结构的。**我看到别人的顺序栈都是用别的方式来写的，我现在这里用的是一维数组，也就是用数组模拟。由于要用到bool型，所以我直接用c++来写，大家可以相应改成C语言的版本，并不难。**顺序栈的操作 无非是基本的...
2020-09-24
yu3332698836的博客
09-24 1104
数据结构，第三周 1.队列是一种插入和删除操作分别在表的两端进行的线性表，是一种先进先出的结构。 对 2.在单链表中，要访问某个结点，只要知道该结点的指针即可。因此，单链表是一种随机存取结构。错 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点都是由元素和指针构成的。” 3.若一个栈的输入序列为1，2，3，…，N，输出序列的第一个元素是i，则第j个输出元素是j−i−1。错 则第j个输出元素是j-i+1. 4.不论是入队列操作还
沟通顺序流程Communicating Sequential Processes
11-15
这是对通信顺序过程（CSP）（一种描述交互模式的语言）及其数学理论的极好的介绍。
Java经典算法汇总之顺序查找(Sequential Search)
09-02
Java查找算法之顺序查找说明：顺序查找适合于存储结构为顺序存储或链接存储的线性表。 下面我们来详细说明下
c语言-通过使用数据结构来实现顺序栈的使用
最新发布
12-27
顺序栈（Sequential Stack）是一种使用数组实现的栈结构。它具有先进后出（Last In, First Out，LIFO）的特点，即最后入栈的元素首先出栈。 顺序栈中的元素按照入栈的顺序存储在数组中，并且通过一个指针来记录栈顶...
基于python的查找算法-顺序查找Sequential Search
06-25
基于python的查找算法-顺序查找Sequential Search
数据结构（C实现）------- 顺序栈
jesson20121020的专栏
09-20 1733
栈是限定仅在表的一端进行插入或删除的纯属表，通常称允许插入，删除的一端为栈顶（Top），相应在的，则称另一端为栈底（Bottom）。不含元素的栈则称为空栈。          所设栈S＝{a1,a2,a3,...,an}，则称a1为栈底元素，an为栈顶元素。根据栈的定义可知，栈顶元素总是最后入栈并且最先出栈的；栈底元素总是最先入栈并且最后出栈的。即栈是按后进先出的原则进行的。因此，栈又称为后进先
C++中overflow错误处理方法
三五月儿的专栏
12-07 6447
<br />今天，用vs2008调试一个C++程序时，出现下列提示：stack overflow。于是，逐步调试，发现错误出在，char str[100000]。仔细想想，原因应该是字符串长度太大，分配内存时，超过了栈的默认大小，一般栈的默认大小为1M。于是按下面步骤修改站和堆的默认大小。“项目”——“属性”——“连接器”——“系统”——将“堆保留大小”、“堆提交大小”、“堆栈保留大小”、“堆栈提交大小”全部改为102400000（单位应该是字节）。再运行，确实没有刚才的错误了，不过这时，又冒出来以下的错误
C# 变量值溢出和方法值溢出，以及OverflowException异常捕捉和处理
number1killer的博客
08-01 9867
众所周知如果变量的值越界的话是无法通过编译的，那么是不是只要发生值越界就会无法通过编译呢？ 很遗憾，编译器虽然聪明，但是还没那么聪明。Visual studio C#编译器只做静态检查，所以在方法中的动态值所导致的值越界编译器是无法在运行之前“检测”到的。 将 decimal 值转换为整型类型时，此值会向零舍入到最接近的整数值。 如果生成的整数值处于目标类型的范围之外，则会引发 Overflo...
字符串转为整形 ATOI (including overflow process)
AlgorithmEngine
04-09 549
#include using namespace std; int myAtoi(char str[]) { int len = strlen(str); int res = 0; bool isNegative = 0; int i = 0; while(i < len) { if(str[i] == ' ') i++; else break; }
顺序栈实验 seqstack （ 注释超详细的） C语言版
qq_44970368的博客
02-15 3850
栈的顺序存储结构简称为顺序栈，本实验通过数组来实现顺序栈。 栈空并不能表示使用的数组也为空 栈满一定表示所用数组已满 顺序栈的说明：可以阅读堆栈或者其他文章进行了解。 步骤说明在注释里 步骤说明在注释里 步骤说明在注释里 代码部分 #include <stdio.h> #define STACK_INTSIZE 50 /*设定栈的最大存储空间*/ typedef char ...
数据结构之顺序栈（StackOrder）与 链式栈（StackList）
ネロ・クラウディウス
11-10 218
栈表 功能被限制的表： 栈：把表结构限制为只有一个端口进出，元素先进后出FILO。 而栈内存正是使用了这种结构管理内存，所以才叫栈内存。 实现功能列表 // 创建栈 StackOrder* create_stack(int cal) // 销毁栈 void destroy_stack(StackOrder* stack) // 栈空 bool empty_stack(StackOrder* stack) // 栈满 bool full_stack(StackOrder* stack) // 入栈 bool
特殊矩阵——三对角矩阵(Tridiagonal Matrix)
热门推荐
Catherine的笔记
06-27 6万+
特殊矩阵——三对角矩阵(Tridiagonal Matrix) 1. 三对角矩阵的概念 三对角矩阵就是对角线、邻近对角线的上下次对角线上有元素，其他位置均为0的矩阵。 三对角矩阵是一种特殊的上Hessenberg矩阵（这个就是上三角矩阵加上下三角部分的第一条次对角线有元素，其他都为0元素）。 2. 三对角矩阵的特性 设一个n*n的方阵A，对于矩阵A中的任一元素aij，当|i-j|>1时，有aij=0(0≤i≤n
sequential probability ratio test 顺序概率比测试
11-30
顺序概率比测试（Sequential Probability Ratio Test，SPRT）是一种用于统计假设检验的方法。这种方法可以帮助我们在一个序列中逐步获取更多的数据，并根据这些数据来判断统计假设。 SPRT的基本思想是，在统计推断中，我们需要根据样本数据来判断某个假设的可行性。然而，如果我们仅仅依赖一次采样数据来进行判断，可能会存在较大的误差。因此，SPRT的核心在于逐步地获取更多的数据，并使用概率比的方法来进行判断。 在进行SPRT时，我们需要设定两个极限。一个是接受（accept）假设的下限，另一个是拒绝（reject）假设的上限。然后，我们开始进行实验并收集数据。在每一步实验中，我们计算当前数据下的概率比，并与两个极限进行比较。如果概率比超过拒绝上限，我们就可以拒绝假设；如果概率比低于接受下限，我们就可以接受假设。如果概率比在两个极限之间，我们继续进行下一步实验。 SPRT的优势在于它可以灵活地根据数据来调整判断过程，减少了对大量数据的需求，从而提高了判断的效率。然而，它也有一些限制。首先，需要事先设定接受和拒绝的极限，这可能会对判断结果产生影响。另外，SPRT要求数据之间是独立同分布的，这在实际应用中可能会有一定的限制。 总之，顺序概率比测试是一种用于统计假设检验的方法，通过逐步获取更多的数据并使用概率比进行判断，可以提高检验的效率。在实际应用中，我们需要根据具体情况来设定极限并注意数据的独立同分布性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值