C++实现堆栈

最新推荐文章于 2026-04-21 13:06:04 发布
原创 最新推荐文章于 2026-04-21 13:06:04 发布 · 2.9k 阅读 · 24 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#堆栈 #c++ #数据结构
本文深入探讨了栈的三种主要存储结构：顺序栈、双堆栈和链栈。详细介绍了每种结构的特点、操作实现及应用场景，通过具体示例帮助读者理解不同栈结构的工作原理。

栈是一种操作受限的线性表。
栈的逻辑结构：插入和删除等操作只能发生在表的一端的特殊的线性表。
栈的物理结构：可以是顺序栈，也可以是链式栈，此外还有一种特殊的双堆栈。

一、顺序栈

顺序栈很大程度上就是个一维数组，只是规定对栈的操作只能在称为栈顶的一端进行。
顺序栈的类型定义通常如下：

/*顺序栈的类型定义*/
struct SeqStack{
    DataType data[MaxSize];
    int top;
};

定义的SeqStack类型由一个data[]数组和一个整型变量top构成，top用来表示当前栈顶元素的位置，也可称其为top指针，其值一般为≥-1的整数。
其结构图大致如下：
顺序栈的结构图
顺序栈的主要操作实现如下：
1.置空栈；初始化栈

void InitStack(SeqStack *s)
{
    s->top=-1;  //也可令top=0;
}

2.判断是否栈空

bool StackEmpty(SeqStack *s)
{
    return(s->top==-1);
}

3.判断是否栈空

bool StackFull(SeqStack *s)
{
    return(s->top==MaxSize-1);
}

4.进栈：在栈顶存入值为x的元素

int Push(SeqStack *s,DataType x)
{
    if(StackFull(s))  //判断栈是否满溢
        return 0;
    s->data[++s->top]=x;
    return 1;
}

5.出栈：取栈顶元素

DataType Pop(SeqStack *s)
{
    if(StackEmpty(s)) //判断栈是否为空
        return 0;
    return(s->data[s->top--]);
}

一个完整的程序：

#include <iostream>
using namespace std;
#define MaxSize 100
typedef int DataType;

/*顺序栈的类型定义*/
struct SeqStack{
    DataType data[MaxSize];
    int top;
};

int main()
{
    void InitStack(SeqStack *s);
    bool StackEmpty(SeqStack *s);
    bool StackFull(SeqStack *s);
    int Push(SeqStack *s,DataType x);
    DataType Pop(SeqStack *s);

    SeqStack p,*s;
    s=&p;
    InitStack(s);          //初始化栈
    for(int i=0;i<=10;i++) //将0~10间的数值存入栈中
        Push(s,i);

    while(!StackEmpty(s)) //当栈为非空时弹出栈顶元素
        cout<<Pop(s)<<' ';
    cout<<endl;
    return 0;
}

/*初始化栈*/
void InitStack(SeqStack *s)
{
    s->top=-1;  //也可令top=0;
}

/*判断是否栈空*/
bool StackEmpty(SeqStack *s)
{
    return(s->top==-1);
}

/*判断是否栈满*/
bool StackFull(SeqStack *s)
{
    return(s->top==MaxSize-1);
}

/*在栈顶存入值为x的元素*/
int Push(SeqStack *s,DataType x)
{
    if(StackFull(s))  //判断栈是否满溢
        return 0;
    s->data[++s->top]=x;
    return 1;
}

/*退栈；取栈顶元素*/
DataType Pop(SeqStack *s)
{
    if(StackEmpty(s)) //判断栈是否为空
        return 0;
    return(s->data[s->top--]);
}

二、双堆栈

在同一个数组里实现两个堆栈的结构可将之称为双堆栈。为最大可能地利用数组空间，可使两个栈分别从数组的两头开始向中间生长，当两个栈的栈顶指针相遇时（RightTop-LeftTop==1），表示两个栈都满了。
双堆栈的结构图如下：
在这里插入图片描述
定义双堆栈的结构类型时，相较于顺序栈，只需多加一个表示第二个栈栈顶的指针即可，可作如下定义：

/*定义双堆栈结构*/
struct DStack
{
    ElementType data[MaxSize];
    int LeftTop;
    int RightTop;
};

在使用双堆栈时，可引入一个整型或布尔型的Tag变量，来只是是对左堆栈或右堆栈进行操作。
双堆栈的主要操作实现如下：
1.置空栈：初始化

void InitStack(DStack *s)
{
    s->LeftTop=-1;
    s->RightTop=MaxSize;
}

2.入栈：根据Tag值将元素x读入某一个栈的栈顶

void Push(DStack *s,ElementType x,int Tag)
{
    if(s->RightTop-s->LeftTop==1)
        cout<<"堆栈满"<<endl;
    else{
        if(Tag==1)
            s->data[++(s->LeftTop)]=x;
        else
            s->data[--(s->RightTop)]=x;
    }
}

3.退栈：根据Tag值读出某个栈的元素

ElementType Pop(DStack *s,int Tag)
{
    if(Tag==1){
        if(s->LeftTop==-1){
            cout<<"堆栈1空"<<endl;
            return 0;
        }
        else
            return(s->data[(s->LeftTop)--]);
    }
    else{
        if(s->RightTop==MaxSize){
            cout<<"堆栈2空"<<endl;
            return 0;
        }
        else
            return(s->data[(s->RightTop)++]);
    }
}

下面是一个将-10~10间的正整数存入数组左边，负整数存入数组右边，并将正负数交替输出的完整程序：

#include <iostream>
using namespace std;
#define MaxSize 20
typedef int ElementType;
/*定义双堆栈结构*/
struct DStack
{
    ElementType data[MaxSize];
    int LeftTop;
    int RightTop;
};


int main()
{
    void InitStack(DStack *s);
    void Push(DStack *s,ElementType x,int Tag);
    ElementType Pop(DStack *s,int Tag);

    DStack *s,Stack;
    s=&Stack;
    InitStack(s);
    for(int i=1;i<11;i++)  //将1~10间的整数存在数组的左边
        Push(s,i,1);
    for(int i=-1;i>-11;i--) //将-10~-1间的整数存在数组的右边
        Push(s,i,2);
    while(s->LeftTop!=-1 || s->RightTop!=MaxSize)
    { /*实现±1~±10之间的整数交替输出*/
        cout<<Pop(s,1)<<' ';
        cout<<Pop(s,2)<<' ';
    }
    cout<<endl;

    return 0;
}

/*初始化栈*/
void InitStack(DStack *s)
{
    s->LeftTop=-1;
    s->RightTop=MaxSize;
}

/*入栈：根据Tag值将元素x写入某个栈的栈顶*/
void Push(DStack *s,ElementType x,int Tag)
{
    if(s->RightTop-s->LeftTop==1)
        cout<<"堆栈满"<<endl;
    else{
        if(Tag==1)
            s->data[++(s->LeftTop)]=x;
        else
            s->data[--(s->RightTop)]=x;
    }
}

/*退栈：根据Tag值读出某个栈的栈顶元素*/
ElementType Pop(DStack *s,int Tag)
{
    if(Tag==1){
        if(s->LeftTop==-1){
            cout<<"堆栈1空"<<endl;
            return 0;
        }
        else
            return(s->data[(s->LeftTop)--]);
    }
    else{
        if(s->RightTop==MaxSize){
            cout<<"堆栈2空"<<endl;
            return 0;
        }
        else
            return(s->data[(s->RightTop)++]);
    }
}

程序运行结果如下：
在这里插入图片描述

三、链栈

链栈是栈的链式存储结构，它的运算是受限的单链表，插入和删除操作仅限制在表头位置上进行。像单链表一样，它也可添加一个数据域为空的头结点。
同顺序栈相比，链栈是可扩充的，它没有栈满的问题。
链栈的结构图如下：
链栈结构图
链栈的主要操作实现如下：
0.链栈的类型定义

typedef struct Node
{
    ElementType data;
    Node *next;
}LinkStack;

1.置空栈：初始化链栈

LinkStack *CreateStack()
{
    LinkStack *s;
    s=new LinkStack; /*s是堆栈的数据域为空的头结点*/
    s->next=NULL;
    return(s);
}

2.判断栈是否为空

/*判断链栈是否为空，返回值为布尔型*/
bool IsEmpty(LinkStack *s)
{
    return(s->next==NULL);
}

3.入栈

/*将元素x压入堆栈s的栈顶结点（紧跟头结点之后的那个结点）中*/
void Push(LinkStack *s,ElementType x)
{
    LinkStack *p;
    p=new LinkStack;
    p->data=x;
    p->next=s->next;
    s->next=p;
}

4.出栈

/*返回栈顶元素，并释放该元素对应的栈顶结点*/
ElementType Pop(LinkStack *s)
{
    LinkStack *top;
    ElementType x;

    if(IsEmpty(s)){
        cout<<"under flow"<<endl;
        return 0;
    }
    else{
        top=s->next;
        x=top->data;
        s->next=top->next;
        delete top;
        return(x);
    }
}

一个完整的程序：

#include <iostream>

using namespace std;
typedef int ElementType;

/*链栈的结点类型定义*/
typedef struct Node
{
    ElementType data;
    Node *next;
}LinkStack;

int main()
{
    LinkStack *CreateStack();
    bool IsEmpty(LinkStack *s);
    void Push(LinkStack *s,ElementType x);
    ElementType Pop(LinkStack *s);

    LinkStack *s;
    s=CreateStack();        //构建链栈s的头结点
    for(int i=1;i<=10;i++)  //依次将1~10间的数值作为栈顶元素压入堆栈中
        Push(s,i);

    while(!IsEmpty(s))     //依次弹出堆栈中的栈顶元素，直到堆栈为空
        cout<<Pop(s)<<' ';

    return 0;
}

/*构建一个链栈的头结点，返回该结点的指针*/
LinkStack *CreateStack()
{
    LinkStack *s;
    s=new LinkStack; /*s是堆栈的数据域为空的头结点*/
    s->next=NULL;
    return(s);
}

/*判断链栈是否为空，返回值为布尔型*/
bool IsEmpty(LinkStack *s)
{
    return(s->next==NULL);
}

/*将元素x压入堆栈s的栈顶结点（紧跟头结点之后的那个结点）中*/
void Push(LinkStack *s,ElementType x)
{
    LinkStack *p;
    p=new LinkStack;
    p->data=x;
    p->next=s->next;
    s->next=p;
}

/*返回栈顶元素，并释放该元素对应的栈顶结点*/
ElementType Pop(LinkStack *s)
{
    LinkStack *top;
    ElementType x;

    if(IsEmpty(s)){
        cout<<"under flow"<<endl;
        return 0;
    }
    else{
        top=s->next;
        x=top->data;
        s->next=top->next;
        delete top;
        return(x);
    }
}
MilkLeong
关注
使用C++实现堆栈数据结构
cl6789的博客
08-26 170
堆栈（Stack）是一种常见的数据结构，它遵循后进先出（Last-In-First-Out，LIFO）的原则。在本文中，我将使用C++编程语言来实现一个堆栈数据结构，并提供相应的源代码。通过理解和掌握堆栈的基本原理和操作，我们可以更好地应用堆栈来解决实际的编程问题。首先，我们需要定义一个堆栈类，它将包含用于实现堆栈操作的成员函数和数据成员。在上述代码中，我们使用一个整型数组作为堆栈的内部存储结构，并定义了一个指针。从输出结果可以看出，我们成功地实现了堆栈数据结构，并进行了相应的堆栈操作。
堆栈（Stack）实现（C++）
weixin_43361652的博客
01-28 7851
一. 堆栈（Stack） 堆栈（Stack） 是一种可以存取的数据结构，其主要特征是先进后出（Last-in-first-out, LIFO） 栈顶（Top） 是最后入栈的数据 堆栈可分为静态堆栈（Static Stack）和动态堆栈（Dynamic Stack）两类： Static Stack： 栈的大小固定，可以用数组实现； Dynamic Stack： 栈的大小随需要改变，可以用链表实现 二. 基本操作（Basic Operation） 入栈（Push）：Equivalent to an in
《C++实现数据结构》：堆栈
ancientmoondjay的博客
03-19 886
堆栈是限定插入和删除操作都在表的同一端进行的线性表，是后进先出（LIFO）的线性数据结构。#include <iostream> using namespace std;//堆栈基类 template <typename T> class Stack{ public: virtual bool IsEmpty() const = 0; //若栈空,则返回true virtual
C++数据结构--栈
最新发布
2603_95759313的博客
04-21 606
栈（Stack）是一种遵循“后进先出”（LIFO, Last In First Out）原则的线性数据结构。栈通常有两种实现方式：顺序栈与链式栈，两者各有优劣。但同时从底层来看栈并不是一种新的数据结构，顺序栈的底层依靠数组，链式栈的底层依靠链表。（注意C++中的容器适配器stack，底层默认是deque（双向队列））
C++|堆栈类的实现
weixin_46096297的博客
11-10 2034
创建一个支持int类型的压入和弹出操作的堆栈类（数组） 功能： 公共： 对stack对象进行初始化 检查stack为空或满 将整数压入stack中 从stack中弹出整数 空栈不移任何元素，返回任意值 私有 打印错误信息的私有成员函数 top 数组 任意值 创建stack头文件 #include<iostream> using namespace std; class Stack {//此栈是用了一个数组 public: enum{MaxStack=5};/枚举型，通过Stack::MaxSt
【C/C++基础】堆与栈
weixin_54383080的博客
05-24 3830
关于C/C++中内存分区的知识，关于动态内存分配的知识，关于堆与栈的区分知识、关于动态内存分配与释放的 malloc/free 和 new/delete 使用的知识
C++堆栈详解
热门推荐
xjxSmile的博客
04-13 1万+
前言：我们经常听见一个概念，堆（heap）和栈（stack），其实在数据结构中也有同样的这两个概念，但是这和内存的堆栈是不一样的东西哦，本文也会说明他们之间的区别的，另外，本文的只是是以C/C++为背景来说明，不同的语言在内存管理上面会有区别。本文是第二篇，介绍内存中的堆与栈。   一、C++中的内存概述 1.1 内存的分类标准——五分类 在C++中，内存分成5个区，他们分别是堆，栈，自由存储区，全局/静态存续区，常量存续区。（1）栈：内...
堆栈C++方法实现
weixin_45989534的博客
08-01 821
本文介绍了使用C++实现堆栈(Stack)数据结构的两种方法：链表实现和顺序表实现。堆栈是一种遵循后进先出(LIFO)原则的线性数据结构，主要操作包括压栈(push)和弹栈(pop)。链表实现通过Node结构体构建链式存储，包含构造函数、析构函数、压栈、弹栈、获取栈顶元素和大小等方法。顺序表实现则使用动态数组，增加了resize()函数来处理容量不足的情况。两种实现方式都通过模板类支持泛型编程，并提供了完整的测试代码示例。文章详细说明了每个方法的实现原理和关键代码，为学习堆栈数据结构提供了实践参考。
数据结构——堆栈的C++实现
zxr916的博客
11-02 713
数据结构——堆栈的C++实现 \qquad堆栈的创建、判断是否为空，入栈，出栈操作的C++实现。 #include<iostream> using namespace std; //1.定义 typedef struct Node* Link; struct Node { int num; Link next; }; //2.创建堆栈头结点 Link CreateStack() { Link s; s = new Node; s->next = NULL; return s
堆栈C++实现
qq_62477821的博客
03-11 1319
堆栈
C++堆和栈的区别和联系
weixin_42804519的博客
07-26 541
2017年09月16日 10:39:33 阅读数：1605 参考博客地址：http://blog.csdn.net/hairetz/article/details/4141043 http://blog.csdn.net/handsomesunshineboy/archive/2010/07/14/5734922.aspx C++中，内存分为5个区...
C++中的栈和堆
jinking01的专栏
03-19 2328
由C/C++编译的程序占用的内存分为以下几个部分： 1、栈区（stack）：又编译器自动分配释放，存放函数的参数值，局部变量的值等，其操作方式类似于数据结构的栈。 2、堆区（heap）：一般是由程序员分配释放，若程序员不释放的话，程序结束时可能由OS回收，值得注意的是他与数据结构的堆是两回事，分配方式倒是类似于数据结构的链表。 3、全局区（static）：也叫静态数据内存空间，存储全局变量...
栈的存储结构
LG_DHS的博客
10-22 3022
一、栈的概念 栈是一种只允许在一端进行插入和删除的线性表，它是一种操作受限的线性表。 在表中只允许进行插入和删除的一端称为栈顶（top）。另一端称为栈底（bottom）。 栈的插入操作称为入栈或者进栈（push）。栈的删除操作称为出栈或者退栈（pop）。 当栈中无数据时，我们称为空栈。 栈的特点：先进后出。! 二、栈的顺序存储结构 java实现代码class SqStack{ priv
精选：局部变量、全局变量、堆、堆栈、静态和全局
浪人的专栏
12-08 2039
  一般全局变量存放在数据区，局部变量存放在栈区， 动态变量存放在堆区，函数代码放在代码区。 --------------------------------------------------------------- 栈区是普通的栈数据结构,遵循LIFO后进先出的规则,局部变量安排在那里是ASM时就规定的,这样可以在一个函数结束后平衡堆栈,操作简单,效率高 堆(动态区)在这里应当叫堆栈(不
C++ 堆栈结构（超详解）
田螺姑娘的博客
04-13 4448
C++ 堆栈结构 参考文章：http://blog.chinaunix.net/uid-23860671-id-150568.html 在C语言中的四大存储区。 栈，由编译器自动分配释放 堆，一般由程序员分配释放，若程序员不释放，程序结束时由OS回收。 全局区（静态区），全局变量和静态变量的存放是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另外一块区域。程序结束进行释放。 常量区，程序结束释放。 int a = 0; 全局初始化区 char *p1
C/C++的堆栈内存分配详解
JJ-Li的博客
07-19 1361
堆和栈是C语言中重要的内存分配方式，各有优缺点和适用场景。理解它们的工作原理和使用方法对于编写高效、可靠的C语言程序至关重要
链表栈：取栈顶元素和置栈空 C++实现
啥都不会的博客
08-28 2093
//C++ file #include&lt;string&gt; #include&lt;string.h&gt; using namespace std; struct Elem { char name[10]; Elem *next; }; class SqBT { private: Elem *top; public: SqBT(); ~Sq...
【Dev-c++】C语言数据结构实验——栈
m0_52474147的博客
07-24 1461
试编写一个程序实现顺序栈的各种基本运算（见参考程序2.1），该主程序完成的功能如下（如图2.1）1、认真阅读程序，将未完成的代码补全（红色部分）。注意程序不完整，请将未完成的代码补全（红色部分）。注意程序不完整，请将未完成的代码补全（红色部分）。3、保存和截图程序的运行结果，并结合程序进行分析。2、掌握栈的两种表示和实现顺序和链式。2、实验2.2栈的链式表示和实现。1、实验2.1栈的顺序表示和实现。3、会使用栈解决实际问题。1、理解栈的定义以及特性。2、上机调试，并运行程序。...
数据结构——栈的基本实现与讲解（C++描述）
理想二旬不止 - 专注JAVA技术
10-22 795
image 栈的定义 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 ——百度百科 简单定义：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值