大话数据结构 栈

已于 2023-11-09 10:10:56 修改
阅读量64 收藏
点赞数 1
文章标签： 数据结构
于 2023-10-09 18:48:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73579869/article/details/133711419
版权

顺序栈

前提代码

#include <iostream>

/* 顺序栈结构 */
typedef struct
{
    int data[20];
    int top; /* 用于栈顶指针 */
}SqStack;

bool visit(int c)
{
    cout<<c;
    return true;
}

构造一个空栈S

bool InitStack(SqStack *S)
{ 
    /* S.data=(SElemType *)malloc(MAXSIZE*sizeof(SElemType)); */
    S->top = -1;
    return true;
}




#include <iostream>
using namespace std;

#define MAX_SIZE 100

typedef struct 
{
    int data[MAX_SIZE];
    int top;
} SqStack;

bool InitStack(SqStack *S)
{ 
    S->top = -1;
    return true;
}

int main() 
{
    SqStack stack;
    InitStack(&stack);
    
    cout << "Stack initialized successfully." << endl;
    
    return 0;
}

把S置为空栈

bool ClearStack(SqStack *S)
{ 
    S->top = -1;
    return true;
}

若栈S为空栈，则返回TRUE，否则返回FALSE

bool StackEmpty(SqStack S)
{ 
    if (S.top == -1)
        return true;
    else
        return false;
}

返回S的元素个数，即栈的长度

int StackLength(SqStack S)
{ 
    return S.top + 1;
}

若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR

bool GetTop(SqStack S,int *e)
{
    if (S.top == -1)
        return false;
    else
        *e = S.data[S.top];
    return true;
}

#include <iostream>
using namespace std;

typedef struct 
{
    SElemType data[100];
    int top;
} SqStack;

bool InitStack(SqStack *S)
{ 
    S->top = -1;
    return true;
}

bool GetTop(SqStack S, int *e)
{
    if (S.top == -1)
        return false;
    else
        *e = S.data[S.top];
    return true;
}

int main() 
{
    SqStack stack;
    InitStack(&stack);
    
    // 入栈
    stack.data[++stack.top] = 10;  //++stack.top = 0
    stack.data[++stack.top] = 20;  //++stack.top = 1
    stack.data[++stack.top] = 30;  //++stack.top = 2
    
    // 获取栈顶元素
    SElemType topElement;
    if (GetTop(stack, &topElement) == OK) 
    {
        cout << "Top element: " << topElement << endl;
    } 
    else 
    {
        cout << "Stack is empty." << endl;
    }
    
    return 0;
}

插入元素e为新的栈顶元素

bool Push(SqStack *S,int e)
{
    if(S->top == MAXSIZE -1) /* 栈满 */
    {
        return false;
    }

    S->top++;				/* 栈顶指针增加一 */
    S->data[S->top] = e;  /* 将新插入元素赋值给栈顶空间 */

    return true;
}

int main()
{
    SqStack stack;
    stack.top = -1; // 初始化栈顶指针为-1，表示空栈

    // 入栈操作示例
    SElemType element;
    cout << "请输入要入栈的元素：";
    cin >> element;

    Status pushStatus = Push(&stack, element);
    if (pushStatus == OK)
    {
        cout << "入栈成功！" << endl;
    }
    else
    {
        cout << "入栈失败，栈已满！" << endl;
    }

    return 0;
}

若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR

bool Pop(SqStack *S,int *e)
{ 
    if(S->top == -1)
        return false;

    *e = S->data[S->top];	/* 将要删除的栈顶元素赋值给e */
    S->top--;				/* 栈顶指针减一 */

    return true;
}

从栈底到栈顶依次对栈中每个元素显示

bool StackTraverse(SqStack S)
{
    int i = 0;

    while(i <= S.top)
    {
        visit(S.data[i++]);
    }

    cout<<endl;

    return true;
}

int main() 
{
    int j;
    SqStack s;
    int e;

    if (InitStack(&s)) 
    {
        for (j = 1; j <= 10; j++) 
        {
            Push(&s, j);
        }
    }

    cout << "栈中元素依次为：";
    StackTraverse(s);

    Pop(&s, &e);
    cout << "弹出的栈顶元素 e=" << e << endl;

    cout << "栈空否：" << StackEmpty(s) << "(1:空 0:否)" << endl;
    GetTop(s, &e);

    cout << "栈顶元素 e=" << e << " 栈的长度为" << StackLength(s) << endl;
    ClearStack(&s);

    cout << "清空栈后，栈空否：" << StackEmpty(s) << "(1:空 0:否)" << endl;

    delete[] s.base;

    return 0;
}

两栈共享空间

typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */

两栈共享空间结构

typedef struct 
{
    SElemType data[MAXSIZE];
    int top1;	/* 栈1栈顶指针 */
    int top2;	/* 栈2栈顶指针 */
}SqDoubleStack;

bool visit(SElemType c)
{
    cout<<c;
    return true;
}

构造一个空栈S

bool InitStack(SqDoubleStack *S)
{ 
    S->top1 = -1;
    S->top2 = MAXSIZE;
    return true;
}

把S置为空栈

bool ClearStack(SqDoubleStack *S)
{ 
    S->top1 = -1;
    S->top2 = MAXSIZE;
    return true;
}

若栈S为空栈，则返回TRUE，否则返回FALSE

bool StackEmpty(SqDoubleStack S)
{ 
    if (S.top1 == -1 && S.top2 == MAXSIZE)
        return true;
    else
        return false;
}

返回S的元素个数，即栈的长度

int StackLength(SqDoubleStack S)
{ 
    return (S.top1 + 1) + (MAXSIZE - S.top2);
}

插入元素e为新的栈顶元素

bool Push(SqDoubleStack *S,SElemType e,int stackNumber)
{
    if (S->top1+1 == S->top2)	/* 栈已满，不能再push新元素了 */
        return false;	
    if (stackNumber == 1)			/* 栈1有元素进栈 */         
        S->data[++S->top1] = e; /* 若是栈1则先top1+1后给数组元素赋值。 */
    else if (stackNumber == 2)	/* 栈2有元素进栈 */
        S->data[--S->top2] = e; /* 若是栈2则先top2-1后给数组元素赋值。 */
    return true;
}

若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR

bool Pop(SqDoubleStack *S,SElemType *e,int stackNumber)
{ 
    if (stackNumber==1) 
    {
        if (S->top1==-1) 
            return false; /* 说明栈1已经是空栈，溢出 */
            *e=S->data[S->top1--]; /* 将栈1的栈顶元素出栈 */
    }
    else if (stackNumber==2)
    {           
        if (S->top2==MAXSIZE) 
            return false; /* 说明栈2已经是空栈，溢出 */
        *e=S->data[S->top2++]; /* 将栈2的栈顶元素出栈 */
    }
    return true;
}

遍历并处理S中的所有元素

bool StackTraverse(SqDoubleStack S) 
{
    int i;
    i = 0;
    while (i <= S.top1) 
    {
        visit(S.data[i++]);
    }
    i = S.top2;
    while (i < MAXSIZE) 
    {
        visit(S.data[i++]);
    }
    cout << endl;
    return true;
}

int main() 
{
    int j;
    SqDoubleStack s;
    int e;
    if (InitStack(&s)) 
    {
        for (j = 1; j <= 5; j++) 
        {
            Push(&s, j, 1);
        }
        for (j = MAXSIZE; j >= MAXSIZE - 2; j--) 
        {
            Push(&s, j, 2);
        }
    }

    cout << "栈中元素依次为：";
    StackTraverse(s);

    cout << "当前栈中元素有：" << StackLength(s) << endl;

    Pop(&s, &e, 2);
    cout << "弹出的栈顶元素 e=" << e << endl;
    cout << "栈空否：" << (StackEmpty(s) ? 1 : 0) << "(1:空 0:否)" << endl;

    for (j = 6; j <= MAXSIZE - 2; j++) 
    {
        Push(&s, j, 1);
    }

    cout << "栈中元素依次为：";
    StackTraverse(s);

    cout << "栈满否：" << (Push(&s, 100, 1) ? 0 : 1) << "(1:否 0:满)" << endl;

    ClearStack(&s);
    cout << "清空栈后，栈空否：" << (StackEmpty(s) ? 1 : 0) << "(1:空 0:否)" << endl;

    return 0;
}

链栈

前提代码

#include <iostream>
#include <cstdlib>
#include <cmath>
#include <ctime>

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */


/* 链栈结构 */
typedef struct StackNode
{
    SElemType data;
    struct StackNode *next;
}StackNode,*LinkStackPtr;


typedef struct
{
    LinkStackPtr top;
    int count;
}LinkStack;

bool visit(SElemType c)
{
    cout<<c;
    return true;
}

构造一个空栈S

bool InitStack(LinkStack *S)
{ 
    S->top = new StackNode;
    if(!S->top)
        return false;
    S->top = NULL;
    S->count = 0;
    return true;
}

把S置为空栈

bool ClearStack(LinkStack *S)
{ 
    LinkStackPtr p,q;
    p = S->top;
    while(p)
    {  
        q = p;
        p = p->next;
        free(q);
    } 
        S->count = 0;
        return true;
}

若栈S为空栈，则返回TRUE，否则返回FALSE

bool StackEmpty(LinkStack S)
{ 
    if (S.count == 0)
        return true;
    else
        return false;
}

返回S的元素个数，即栈的长度

int StackLength(LinkStack S)
{ 
    return S.count;
}

若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR

bool GetTop(LinkStack S,SElemType *e)
{
    if (S.top == NULL)
        return false;
    else
        *e = S.top->data;
    return true;
}

插入元素e为新的栈顶元素

bool Push(LinkStack *S,SElemType e)
{
    //LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode)); 
    LinkStackPtr s = new StackNode;
    s->data = e; 
    s->next = S->top;	/* 把当前的栈顶元素赋值给新结点的直接后继，见图中① */
    S->top = s;         /* 将新的结点s赋值给栈顶指针，见图中② */
    S->count++;
    return true;
}

若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR

bool Pop(LinkStack *S,SElemType *e)
{ 
    LinkStackPtr p;
    if(StackEmpty(*S))
        return false;
    *e = S->top->data;
    p = S->top;					/* 将栈顶结点赋值给p，见图中③ */
    S->top = S->top->next;    /* 使得栈顶指针下移一位，指向后一结点，见图中④ */
    free(p);                    /* 释放结点p */        
    S->count--;
    return true;
}

bool StackTraverse(LinkStack S)
{
    LinkStackPtr p;
    p = S.top;
    while(p)
    {
         visit(p->data);
         p = p->next;
    }
    cout<<endl;
    return true;
}

int main()
{
    int j;
    LinkStack s;
    int e;
    if (InitStack(&s) == OK)
        for (j = 1; j <= 10; j++)
            Push(&s, j);
    cout << "栈中元素依次为：";
    StackTraverse(s);
    Pop(&s, &e);
    cout << "弹出的栈顶元素 e=" << e << endl;
    cout << "栈空否：" << StackEmpty(s) << "(1:空 0:否)" << endl;
    GetTop(s, &e);
    cout << "栈顶元素 e=" << e << " 栈的长度为" << StackLength(s) << endl;
    ClearStack(&s);
    cout << "清空栈后，栈空否：" << StackEmpty(s) << "(1:空 0:否)" << endl;
    return 0;
}

北京理工大学软件工程
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构.mdaaa
07-08
本次内容将围绕“栈”、“队列”、“树”以及“二叉树”等基本数据结构进行深入探讨，并对Java中的`HashMap`实现进行解析。 ### 栈 栈是一种特殊的线性数据结构，其特点是后进先出（LIFO）。即最后进入栈的数据...
大话设计结构代码
11-21
《大话设计结构代码》这本书深入浅出地探讨了数据结构这一重要计算机科学主题，它在编程和软件工程中占据着核心地位。数据结构是组织和管理数据的方式，有效地使用数据结构可以极大地提高程序的效率和可维护性。以下...
大话数据结构——栈与队列
BANANA_KAY的博客
08-23 500
栈（stack）是限定仅在表尾进行插入和删除操作的线性表。把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom）。队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
大话数据结构-栈
村长Korbin
03-02 483
栈（stack）是限定仅在表尾进行插入和删除操作的线性表，是后进先出的线性表，顺序存储结构及代码实现，两栈共享空间的实现，链式存储结构链栈的实现。中缀表示法、前缀表示法、后缀表示法及代码实现。
大话数据结构 栈与队列2022.1.7
weixin_45696295的博客
01-08 270
栈和队列
《大话数据结构》8——数据结构-栈（代码、实例、应用、概念）
weixin_45594172的博客
03-18 542
《大话数据结构》8——数据结构-栈（代码、实例、应用、概念）
大话数据结构PDF
热门推荐
weixin_42528734的博客
07-17 4万+
《大话数据结构》相关下载地址重难点目录 下载地址 云盘： touch here. 提取码： 93dc 重难点目录 第一章 绪论 逻辑结构，物理存储结构（顺序和链式） 数据结构类型 第二章 算法 时间复杂度和空间复杂度，计算方法 最坏情况、平均情况。 第三章 链表 动态链表：指针，常用 静态链表：数组，无指针语言（Basic）使用，较少用 循环链表：（单循环）next 双向链表：next，prior 双向循环链表，插入时候的指针改动，顺序非常重要。–》 第四章
大话数据结构四（栈）
学习记录
03-23 239
1、栈的定义 1.栈的定义 先进去，却要后出来，而后进的反而可以先出来的数据结构—栈 例子：浏览器的后退键，点击后可以按访问顺序的逆序加载浏览过的网页 栈是限定仅在表尾进行插入和删除操作的线性表 我们把允许插入和删除的一端称为栈顶（top)，另外一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出的线性表 进栈： 栈的插入操作，也称压栈、入栈 出栈： 栈的删除操作，也叫弹栈 2.进栈出栈变化形式 最先进栈的元素，不一定最后出栈 比如，如果有3个整型数字元素1、2、3
大话数据结构---栈
weixin_47015735的博客
09-18 98
数据结构---栈1、栈的顺序存储结构- 结构定义- 进栈操作- 出栈操作2、两栈共享空间- 结构定义- 进栈操作- 出栈操作3、栈的链式存储结构(链栈）- 结构定义- 进栈操作- 出栈操作4、中缀表达式转后缀表达式、后缀表达式的计算 1、栈的顺序存储结构 - 结构定义 typedef int SElemType; typedef struct { SElemType data[MAXSIZE]; int pop; /*用于栈顶指针*/ }SqStack; - 进栈操作 /*插入元素e为新的栈顶元
《大话数据结构》——栈与队列
fengwenpei的博客
11-10 461
栈 栈的定义 栈（stack）是限定仅在表尾进行插入和删除操作的线性表 栈顶（top）允许插入和删除的一端，另一端叫栈底（bottom） 栈：先入后出，类似弹夹 栈的顺序存储结构 即用数组来实现栈，数组头即下标为0的位置为栈底，以一个top变量来指示栈顶元素 栈的链式存储结构 栈顶用来插入和删除，故用链表的头部作为栈顶最合适，这样插入和删除的操作时间复杂度就是O(1) 栈的作用 实现递归 实现四则运算表达式求值：涉及中缀表达式转换为后缀表达式的过程 队列 队列的定义 队列（queue）只允
《大话数据结构》06 栈
阿钊侃技术的博客
04-19 1217
栈是我们在数据结构和任何编程语言中都无法绕开的一个关键节点，这篇文章让你彻底读懂栈
数据结构课件完整版
11-04
本课件涵盖了数据结构的多个重要主题，包括线性表、栈和队列、串、数和二叉树、图、查找以及内部排序。 线性表是最基本的数据结构之一，它是一组按顺序排列的元素集合。每个元素都有一个唯一的索引，可以实现快速...
算法与数据结构c与c++描述
03-12
3. **栈**：后进先出（LIFO）的数据结构，常用操作为压栈（push）和弹栈（pop）。 4. **队列**：先进先出（FIFO）的数据结构，常用操作为入队（enqueue）和出队（dequeue）。 5. **哈希表**：通过哈希函数快速定位...
数据结构----栈
新手嵌入式学习的博客
08-19 951
数据结构顺序栈和链式栈。
集合及数据结构第三节————包装类和简单认识泛型
2301_79418684的博客
08-19 1134
包装类和简单认识泛型 1. 基本数据类型和对应的包装类 2. 装箱和拆箱 3. 泛型 4. 泛型类的使用 5. 裸类型(Raw Type) （了解） 6. 泛型如何编译的 7. 泛型的上界 8. 泛型方法
【数据结构-距离合】力扣1685. 有序数组中差绝对值之和
最新发布
sjsjs11的博客
08-20 298
换句话说， result[i] 等于 sum(|nums[i]-nums[j]|) ，其中 0 <= j < nums.length 且 j!请你建立并返回一个整数数组 result，它跟 nums 长度相同，且result[i] 等于 nums[i] 与数组中所有其他元素差的绝对值之和。，可以得到每个元素和其他元素的绝对值之和与该元素以及左边元素和及右边元素和之间的关系，进行计算即可。输入：nums = [1,4,6,8,10]输出：[24,15,13,15,21]输入：nums = [2,3,5]
数据结构（邓俊辉）学习笔记】优先级队列 06——完全二叉堆：批量建堆
weixin_44399845的博客
08-18 852
完全二叉堆：批量建堆
大话数据结构超清pdf
08-17
很抱歉，根据提供的引用内容，我没有找到关于《大话数据结构》超清PDF的相关信息。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* *2* *3* [算法与数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值