数据结构 03 栈和队列

im_AMBER2025-10-16 17:04

1 栈的基本操作（固定容量）

1. 定义栈的结构

cpp 复制代码 
#define MAXSIZE 100 // 定义栈的最大容量
typedef int ElemType; // 定义栈中元素的类型，这里假设为 int
typedef struct {
    ElemType data[MAXSIZE]; // 用数组存储栈元素
    int top; // 栈顶指针，初始为 -1，表示栈空
} SqStack;
结构体定义的作用
cpp 复制代码 
typedef struct {
    ElemType data[MAXSIZE]; // 用数组存储栈元素
    int top; // 栈顶指针，初始为 -1，表示栈空
} SqStack;

这段结构体定义的作用是创建一个栈（顺序栈）的数据结构模型，用于规范栈的存储方式和基本属性。我们来详细拆解它的作用：

1. 定义栈的存储结构

  • ElemType data[MAXSIZE]：这是一个数组，用于实际存储栈中的元素。

    • ElemType 是提前定义的元素类型（这里是 int），方便后续修改栈存储的数据类型（比如改成 float 或自定义结构体）。
    • MAXSIZE 是栈的最大容量，定义了栈最多能存储多少个元素。

  • int top：这是栈顶指针，用于标记栈顶元素的位置，是栈操作的核心标记：

    • 初始值为 -1，表示栈为空（没有元素）。
    • 当有元素入栈时，top 加 1；元素出栈时，top 减 1。
    • 通过 top 的值可以判断栈的状态：top == -1 表示栈空，top == MAXSIZE - 1 表示栈满。
2. 通过 typedef 简化使用

  • typedef 关键字将这个结构体起了一个别名 SqStack（Sequential Stack，顺序栈）。

  • 之后可以直接用 SqStack 来定义栈变量，而不需要每次都写 struct {...}，例如：

    cpp 复制代码 
    SqStack stack; // 定义一个栈变量，比写 struct {...} stack 更简洁
3. 封装栈的属性

这个结构体将栈的存储空间（data 数组） 和状态标记（top 指针） 封装在一起，形成一个完整的栈对象。这样做的好处是：

  • 操作栈时可以直接通过结构体变量访问这两个核心属性（例如 stack.top、stack.data[i]）。
  • 使代码逻辑更清晰，一看就知道这是一个栈结构，包含存储元素的空间和栈顶标记。
总结

简单说，这个结构体的作用就是为栈这种数据结构制定一个 "模板" ，规定了栈应该如何存储数据、如何标记状态，并且通过 typedef 简化了这个模板的使用。后续对栈的所有操作（入栈、出栈、取栈顶元素等），都是基于这个结构体来实现的。

2. 初始化栈（InitStack(&S)）

cpp 复制代码 
// 初始化栈
void InitStack(SqStack *S) {
    S->top = -1; // 将栈顶指针置为 -1，栈空
}

解释 ：初始化时，把栈顶指针 top 设为 -1，表示栈里还没有元素，这样后续入栈操作可以从数组下标 0 开始存储元素。

(SqStack *S)

(SqStack *S) 表示函数 InitStack 的参数，它的含义是：声明一个指向 SqStack 类型结构体的指针变量 S。

我们来详细拆解：

  1. SqStack ：这是我们之前通过 typedef 定义的结构体别名（表示 "顺序栈"），代表栈的数据结构类型。

  2. * ：这是指针符号，说明 S 是一个指针变量，它存储的是内存地址，而不是实际的结构体数据。

  3. S：是这个指针变量的名称，用于在函数内部访问它指向的结构体。

为什么要用指针作为参数？

在 InitStack 函数中，我们的目的是初始化一个栈 （将栈顶指针 top 设为 -1）。由于 C 语言的函数参数传递是 "值传递"（即函数内部会复制一份参数），如果直接传结构体变量（SqStack S），函数内部修改的只是复制的临时变量，不会影响外部的原变量。

而传递指针（SqStack *S）时，函数内部可以通过指针直接访问和修改原结构体变量的内存空间，这样初始化操作才能真正生效。

例如，在主函数中这样调用：

cpp 复制代码 
SqStack stack;       // 定义一个栈结构体变量
InitStack(&stack);   // &stack 表示取 stack 的地址，传给指针参数 S

此时函数内部的 S->top = -1 等价于 (*S).top = -1，实际修改的是外部 stack 变量的 top 成员。

简单说，(SqStack *S) 的作用是：让函数能够 "找到" 并修改外部定义的栈结构体变量，确保初始化操作能真正作用于目标栈。

3. 销毁栈（DestroyStack(&S)）

对于顺序栈，因为是用数组（静态分配内存）实现的，内存是由系统自动管理的，所以销毁操作比较简单，只需将栈顶指针置为 -1 即可，相当于逻辑上销毁。

cpp 复制代码 
// 销毁栈
void DestroyStack(SqStack *S) {
    S->top = -1; // 栈顶指针置为 -1，栈空，逻辑上销毁
}

解释 ：由于数组是在栈结构定义时静态分配的内存，不需要我们手动释放，所以将 top 设为 -1，让栈回到初始的空状态，就完成了销毁操作。

4. 判断栈是否为空（StackEmpty(S)）

cpp 复制代码 
// 判断栈是否为空
int StackEmpty(SqStack S) {
    if (S.top == -1) {
        return 1; // 栈空，返回 1
    } else {
        return 0; // 栈非空，返回 0
    }
}

解释 ：根据栈顶指针 top 的值来判断。如果 top == -1，说明栈里没有元素，返回 1 表示栈空；否则返回 0 表示栈非空。

5. 获取栈的长度（StackLength(S)）

cpp 复制代码 
// 获取栈的长度
int StackLength(SqStack S) {
    return S.top + 1; // 栈顶指针 + 1 就是栈中元素的个数
}

解释 ：因为栈顶指针 top 从 -1 开始，每入栈一个元素，top 就加 1。所以栈中元素的个数就是 top + 1，直接返回这个值即可。

6. 获取栈顶元素（GetTop(S, &e)）

cpp 复制代码 
// 获取栈顶元素
int GetTop(SqStack S, ElemType *e) {
    if (S.top == -1) {
        return 0; // 栈空，获取失败
    }
    *e = S.data[S.top]; // 将栈顶元素赋值给 e
    return 1; // 获取成功
}

解释 ：首先判断栈是否为空，如果为空，返回 0 表示获取失败。如果栈非空，栈顶元素是数组中 top 下标对应的元素，将其赋值给 e，返回 1 表示获取成功。

7. 入栈（Push(&S, e)）

cpp 复制代码 
// 入栈
int Push(SqStack *S, ElemType e) {
    if (S->top == MAXSIZE - 1) {
        return 0; // 栈满，入栈失败
    }
    S->top++; // 栈顶指针上移
    S->data[S->top] = e; // 将元素 e 放入栈顶
    return 1; // 入栈成功
}

解释 ：先判断栈是否已满（top == MAXSIZE - 1），如果已满，返回 0 表示入栈失败。如果栈未满，先将栈顶指针 top 加 1，然后把要入栈的元素 e 放到新的栈顶位置，返回 1 表示入栈成功。

8. 出栈（Pop(&S, &e)）

cpp 复制代码 
// 出栈
int Pop(SqStack *S, ElemType *e) {
    if (S->top == -1) {
        return 0; // 栈空，出栈失败
    }
    *e = S->data[S->top]; // 将栈顶元素赋值给 e
    S->top--; // 栈顶指针下移
    return 1; // 出栈成功
}

解释 ：首先判断栈是否为空，若为空，返回 0 表示出栈失败。若栈非空，先把栈顶元素（top 下标对应的元素）赋值给 e，然后将栈顶指针 top 减 1，返回 1 表示出栈成功。

9. 遍历栈（StackTraverse(S, visit())）

cpp 复制代码 
// 遍历栈的函数，这里假设 visit 是打印元素的函数
void visit(ElemType e) {
    printf("%d ", e);
}
// 遍历栈
void StackTraverse(SqStack S, void (*visit)(ElemType)) {
    int i;
    for (i = 0; i <= S.top; i++) {
        visit(S.data[i]); // 调用 visit 函数处理每个元素
    }
    printf("\n");
}

解释 ：从栈底（数组下标 0）到栈顶（数组下标 top）依次调用 visit 函数处理每个元素。这里的 visit 函数可以根据需求自定义，比如打印元素、对元素进行某种计算等。示例中 visit 函数是打印元素。

测试代码

下面是一个简单的测试代码，来验证这些操作：

cpp 复制代码 
#include <stdio.h>
int main() {
    SqStack S;
    ElemType e;
    // 初始化栈
    InitStack(&S);
    printf("栈是否为空：%d\n", StackEmpty(S));
    // 入栈
    Push(&S, 1);
    Push(&S, 2);
    Push(&S, 3);
    printf("栈的长度：%d\n", StackLength(S));
    // 获取栈顶元素
    GetTop(S, &e);
    printf("栈顶元素：%d\n", e);
    // 遍历栈
    printf("遍历栈：");
    StackTraverse(S, visit);
    // 出栈
    Pop(&S, &e);
    printf("出栈元素：%d\n", e);
    printf("出栈后遍历栈：");
    StackTraverse(S, visit);
    // 销毁栈
    DestroyStack(&S);
    printf("销毁后栈是否为空：%d\n", StackEmpty(S));
    return 0;
}

输出结果：

plaintext

bash 复制代码 
栈是否为空：1
栈的长度：3
栈顶元素：3
遍历栈：1 2 3
出栈元素：3
出栈后遍历栈：1 2
销毁后栈是否为空：1

2 栈的基本操作（可动态扩展容量）

这是可动态扩展容量的顺序栈的结构定义，和之前固定容量的顺序栈相比，它能在栈满时自动增加存储空间。我们来详细解释并实现其基础操作。

1. 定义栈的结构

cpp 复制代码 
#define STACK_INIT_SIZE 100   // 栈的初始容量
#define STACKINCREMENT 10     // 栈容量的增量
typedef int ElemType;         // 定义栈中元素的类型，这里假设为 int
typedef struct {
    ElemType *base;   // 栈底指针，指向栈的起始位置
    ElemType *top;    // 栈顶指针，指向栈顶元素的下一个位置
    int stacksize;    // 当前栈的容量
} SqStack;

2. 初始化栈（InitStack）

cpp 复制代码 
// 初始化栈
int InitStack(SqStack *S) {
    // 分配初始容量的内存
    S->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if (!S->base) {
        return 0; // 内存分配失败
    }
    S->top = S->base; // 栈顶指针初始时与栈底指针重合，栈空
    S->stacksize = STACK_INIT_SIZE; // 设置初始栈容量
    return 1; // 初始化成功
}

解释 ：为栈分配初始容量的内存，栈底指针 base 指向分配内存的起始位置，栈顶指针 top 初始时和 base 重合，表示栈空，同时设置好初始的栈容量 stacksize。

S->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));

这句代码是在 C 语言中为栈分配初始内存空间的关键操作，我们一步步拆解它的含义：

cpp 复制代码 
S->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));

1. 从右往左看：malloc(...)

  • malloc 是 C 语言的内存分配函数，作用是向计算机申请一块内存空间。
  • 括号里的 STACK_INIT_SIZE * sizeof(ElemType) 是要申请的内存大小（单位：字节）：
    • STACK_INIT_SIZE 是我们定义的宏（初始容量，比如 100），表示栈一开始能存多少个元素。
    • sizeof(ElemType) 计算一个 ElemType 类型（这里是 int）占用的字节数（比如 int 通常是 4 字节）。
    • 两者相乘就是：总字节数 = 元素个数 × 单个元素大小（例如 100 × 4 = 400 字节）。

2. 中间部分：(ElemType *)

  • 这是强制类型转换 ，因为 malloc 函数返回的是 void * 类型（通用指针，不明确指向哪种数据类型）。
  • 我们需要把它转换成 ElemType * 类型（指向 ElemType 类型的指针），这样才能和左边的 S->base 匹配。

3. 左边部分：S->base = ...

  • S 是指向 SqStack 结构体的指针（之前定义的栈结构）。
  • -> 是指针访问结构体成员的运算符，S->base 表示访问 S 指向的结构体中的 base 成员（栈底指针）。
  • 整个赋值的意思是：把刚才申请的内存空间的起始地址，存到栈的 base 指针里 ，让 base 指向这块内存的开头。

通俗理解

这句话就像：

  1. 告诉计算机："我需要一块能装下 100 个 int 类型数据的空间"（计算大小）。
  2. 计算机分配好空间后，返回这个空间的 "门牌号"（内存地址）。
  3. 我们把这个 "门牌号" 记到栈的 base 成员里（以后就通过 base 找到这块空间）。

为什么要这样做？

  • 栈需要一块连续的内存来存储元素，malloc 就是用来申请这块内存的。
  • base 指针记录内存的起始位置，以后所有元素的存储、访问都从这个位置开始。
  • 如果申请失败（比如内存不足），malloc 会返回 NULL，所以后面通常会判断是否申请成功。

例如，如果 ElemType 是 int（4 字节），STACK_INIT_SIZE 是 100，那么这句代码会申请 400 字节的内存，并让 base 指向这块内存的开头。

3. 销毁栈（DestroyStack）

cpp 复制代码 
// 销毁栈
void DestroyStack(SqStack *S) {
    if (S->base) {
        free(S->base); // 释放栈的内存
        S->base = NULL;
        S->top = NULL;
        S->stacksize = 0;
    }
}

解释 ：如果栈底指针 base 不为空，说明有分配的内存，将其释放，并把相关指针置空，栈容量设为 0。

4. 判断栈是否为空（StackEmpty）

cpp 复制代码 
// 判断栈是否为空
int StackEmpty(SqStack S) {
    return S.top == S.base; // 栈顶指针和栈底指针重合则栈空
}

解释 ：当栈顶指针 top 和栈底指针 base 重合时，说明栈中没有元素，返回 1 表示栈空，否则返回 0。

5. 获取栈的长度（StackLength）

cpp 复制代码 
// 获取栈的长度
int StackLength(SqStack S) {
    return S.top - S.base; // 栈顶指针与栈底指针的差值就是元素个数
}

解释 ：由于栈顶指针 top 指向栈顶元素的下一个位置，栈底指针 base 指向栈的起始位置，两者的差值就是栈中元素的个数。

6. 获取栈顶元素（GetTop）

cpp 复制代码 
// 获取栈顶元素
int GetTop(SqStack S, ElemType *e) {
    if (S.top == S.base) {
        return 0; // 栈空，获取失败
    }
    *e = *(S.top - 1); // 栈顶元素是栈顶指针的前一个位置的元素
    return 1; // 获取成功
}

解释 ：先判断栈是否为空，若为空则获取失败。若栈非空，栈顶元素在栈顶指针 top 的前一个位置，将其赋值给 e，获取成功。

为什么这里不需要用指针 *S

在这个 GetTop 函数中，参数使用 SqStack S（结构体变量）而不是 SqStack *S（结构体指针），是因为这个函数只需要读取栈的内容，不需要修改栈本身。

我们详细解释为什么这里不需要用指针 *S：

1. 先明确 SqStack S 和 SqStack *S 的区别
  • SqStack S：函数参数是结构体变量的副本 。调用函数时，会把原栈的所有数据（base、top、stacksize）复制一份到 S 中。
  • SqStack *S：函数参数是指向结构体的指针。调用函数时，只传递原栈的内存地址，不复制数据，通过地址直接操作原栈。
2. GetTop 函数的需求：只 "读" 不 "改"

GetTop 的作用是获取栈顶元素的值，流程是：

  1. 判断栈是否为空（只需读取 S.top 和 S.base 的值）。
  2. 如果非空，读取栈顶元素的值（*(S.top - 1)），并通过 *e 传出。

整个过程中，不需要修改栈的任何成员 （base、top、stacksize 都保持不变）。因此，即使使用副本 S，也能完成任务 ------ 因为我们只需要读取副本中的数据，不需要影响原栈。

3. 如果用 *S 会怎样？

如果写成 int GetTop(SqStack *S, ElemType *e)，也能实现功能，代码会变成：

cpp 复制代码 
int GetTop(SqStack *S, ElemType *e) {
    if (S->top == S->base) { // 用 -> 访问指针指向的结构体成员
        return 0;
    }
    *e = *(S->top - 1); 
    return 1;
}

这样写也是正确的，只是相比之下：

  • 用 SqStack S 更符合 "只读不修改" 的语义，代码更易理解。
  • 用 SqStack *S 虽然也能运行，但会给人一种 "可能要修改栈" 的暗示（实际上并没有）。
总结

函数参数用不用指针（*），核心看是否需要修改原变量：

  • 如果需要修改原栈（如 InitStack、Push、Pop），必须用指针 *S，否则修改的只是副本，原栈不会变化。
  • 如果只需要读取栈的数据（如 GetTop、StackEmpty、StackLength），可以不用指针，直接传结构体变量的副本即可。

GetTop 属于 "只读" 操作，因此不需要用 *S。

7. 入栈（Push）

cpp 复制代码 
// 入栈
int Push(SqStack *S, ElemType e) {
    // 栈满，需要扩展容量
    if (S->top - S->base >= S->stacksize) {
        ElemType *newBase = (ElemType *)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(ElemType));
        if (!newBase) {
            return 0; // 内存重新分配失败
        }
        S->base = newBase;
        S->top = S->base + S->stacksize; // 调整栈顶指针
        S->stacksize += STACKINCREMENT; // 增加栈容量
    }
    *(S->top) = e; // 存入元素
    S->top++; // 栈顶指针上移
    return 1; // 入栈成功
}

解释 ：先判断栈是否已满，若已满则重新分配更大的内存，调整栈底指针、栈顶指针和栈容量。然后将元素存入栈顶指针 top 指向的位置，栈顶指针上移。

ElemType *newBase = (ElemType *)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(ElemType));

这行代码主要用于在栈满时对栈所占用的内存空间进行动态扩容，下面详细解释其各部分的含义：

从右往左看
1. (S->stacksize + STACKINCREMENT) * sizeof(ElemType)
  • S->stacksize：S 是指向 SqStack 结构体的指针，-> 是指针访问结构体成员的运算符，S->stacksize 表示获取当前栈的容量大小，即当前栈最多能容纳的元素个数。
  • STACKINCREMENT：这是一个通过 #define 定义的宏，代表每次栈容量需要增加的数量， 比如定义为 10，就表示每次扩容增加 10 个元素的存储容量。
  • sizeof(ElemType)：sizeof 是 C 语言的操作符，用于计算数据类型 ElemType 所占用的字节数，ElemType 是栈中元素的数据类型，在这里被定义为 int，通常情况下 int 类型占用 4 个字节。

三者相乘，得到的结果就是需要重新分配的内存空间的总字节数，也就是扩容后栈总共需要的内存大小。比如原来栈容量 S->stacksize 为 100，STACKINCREMENT 为 10，ElemType 是 int，那么这里计算出的总字节数就是 (100 + 10) * 4 = 440 字节。

2. realloc(S->base, ...)
  • realloc 是 C 语言中的内存重新分配函数，它有两个参数。
  • 第一个参数 S->base 是原来已分配内存块的起始地址，也就是当前栈所占用内存空间的起始位置。realloc 函数会根据第二个参数指定的新的内存大小，对原来由 S->base 指向的内存块进行调整。调整的方式有以下几种情况：
    • 如果新的内存大小比原来小，realloc 会截断原来的内存块，并返回截断后内存块的起始地址。
    • 如果新的内存大小比原来大，并且原来的内存块后面有足够的连续空闲内存空间，realloc 会在原来内存块的基础上直接扩展，然后返回扩展后内存块的起始地址。
    • 如果新的内存大小比原来大，但是原来内存块后面没有足够的连续空闲内存空间，realloc 会在其他合适的内存位置重新分配一块满足新大小要求的内存块，然后把原来内存块中的数据复制到新的内存块中，释放原来的内存块，最后返回新内存块的起始地址。
  • realloc 函数执行成功时，返回重新分配后的内存块的起始地址；如果执行失败（比如内存不足无法分配足够的空间），则返回 NULL。
中间部分

(ElemType *) 是强制类型转换操作符，因为 realloc 函数返回的是 void * 类型（通用指针类型，可以指向任何类型的数据），而我们需要将其转换为 ElemType * 类型，也就是指向栈中元素类型的指针，这样才能将其赋值给 newBase。

左边部分

ElemType *newBase = ... 表示定义一个指向 ElemType 类型的指针变量 newBase，然后将 realloc 函数返回的地址赋值给 newBase，通过这个指针，后续就可以访问扩容后的栈内存空间。

简单来说，这行代码的作用就是在栈满时，重新分配一块更大的内存空间用于存储栈中的元素，并且通过 newBase 指针指向这块新的内存空间，以便后续对栈进行操作。

8. 出栈（Pop）

cpp 复制代码 
// 出栈
int Pop(SqStack *S, ElemType *e) {
    if (S->top == S->base) {
        return 0; // 栈空，出栈失败
    }
    S->top--; // 栈顶指针下移
    *e = *(S->top); // 将栈顶元素赋值给 e
    return 1; // 出栈成功
}

解释 ：先判断栈是否为空，若为空则出栈失败。若栈非空，栈顶指针下移，将此时栈顶指针指向的元素赋值给 e，出栈成功。

【和链表不同，s->top 为什么不是 s->top = s -> top -> next而是能够直接--】

在栈的实现中，s->top-- 这种操作方式与链表的 s->top = s->top->next 不同，核心原因是顺序栈和链表栈的存储结构本质不同。

我们来详细对比理解：

1. 顺序栈的存储本质：连续的数组空间

顺序栈（用数组实现的栈）的本质是一块连续的内存空间（数组），栈的所有元素在内存中是紧挨着存放的。例如：

复制代码 
数组索引：0  1  2  3  ... （连续的下标）
元素值：  a  b  c  d  ... （连续存储）

在这种结构中：

  • top 本质是数组的下标（或指向数组元素的指针），用于标记栈顶元素的位置。
  • 由于数组下标是连续递增的（0→1→2→...），栈顶指针的移动只需要通过 ++ 或 -- 操作即可完成。

出栈时：

  • 原来的 top 指向栈顶元素的下一个位置（如指向索引 4，栈顶元素在索引 3）。
  • 执行 s->top-- 后，top 就指向了原来的栈顶元素（索引 3），相当于完成了栈顶的 "下移"。
2. 链表栈的存储本质：离散的节点 + 指针连接

链表栈的元素是分散存储在内存中的节点 ，每个节点通过 next 指针连接到下一个节点，内存中不一定连续：

复制代码 
节点1：值a → next→ 节点2：值b → next→ 节点3：值c → ...（离散存储）

在这种结构中：

  • top 是指向头节点的指针，每个节点的位置在内存中是随机的，没有连续的下标。
  • 要移动栈顶，必须通过节点的 next 指针（s->top = s->top->next），才能找到下一个节点的位置。
3. 核心区别总结
类型 存储方式 top 的本质 移动栈顶的方式 原因
顺序栈 连续数组 数组下标 / 连续指针 top++/top-- 元素连续存储，下标递增
链表栈 离散节点 + 指针 指向头节点的指针 top = top->next 元素离散存储，靠指针连接

简单说：顺序栈因为元素在内存中 "挨在一起"，所以栈顶指针的移动像 "走连续的台阶"，用 -- 就能完成；而链表栈的元素 "散落各处"，必须通过 next 指针才能找到下一个位置，就像 "跳格子" 需要知道下一格的位置一样。

9. 遍历栈（StackTraverse）

cpp 复制代码 
// 遍历栈的函数，这里假设 visit 是打印元素的函数
void visit(ElemType e) {
    printf("%d ", e);
}
// 遍历栈
void StackTraverse(SqStack S, void (*visit)(ElemType)) {
    ElemType *p = S.base;
    while (p < S.top) {
        visit(*p); // 调用 visit 函数处理每个元素
        p++;
    }
    printf("\n");
}

解释 ：从栈底指针 base 开始，到栈顶指针 top 结束，依次调用 visit 函数处理每个元素。示例中 visit 函数是打印元素。

测试代码

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main() {
    SqStack S;
    ElemType e;
    // 初始化栈
    if (!InitStack(&S)) {
        printf("栈初始化失败\n");
        return 1;
    }
    printf("栈是否为空：%d\n", StackEmpty(S));
    // 入栈
    Push(&S, 1);
    Push(&S, 2);
    Push(&S, 3);
    printf("栈的长度：%d\n", StackLength(S));
    // 获取栈顶元素
    if (GetTop(S, &e)) {
        printf("栈顶元素：%d\n", e);
    } else {
        printf("获取栈顶元素失败\n");
    }
    // 遍历栈
    printf("遍历栈：");
    StackTraverse(S, visit);
    // 出栈
    if (Pop(&S, &e)) {
        printf("出栈元素：%d\n", e);
    } else {
        printf("出栈失败\n");
    }
    printf("出栈后遍历栈：");
    StackTraverse(S, visit);
    // 销毁栈
    DestroyStack(&S);
    printf("销毁后栈是否为空：%d\n", StackEmpty(S));
    return 0;
}

输出结果：

plaintext

bash 复制代码 
栈是否为空：1
栈的长度：3
栈顶元素：3
遍历栈：1 2 3
出栈元素：3
出栈后遍历栈：1 2
销毁后栈是否为空：1

这种可动态扩展容量的顺序栈，能更好地适应元素个数不确定的情况，避免了固定容量顺序栈可能出现的提前栈满或内存浪费的问题。

相关推荐
✎ ﹏梦醒͜ღ҉繁华落℘2 小时前
FreeRTOS学习笔记（应用）-- 各种 信号量的应用场景
笔记·学习
星星火柴9362 小时前
笔记 | C++面向对象高级开发
开发语言·c++·笔记·学习
Coovally AI模型快速验证2 小时前
当视觉语言模型接收到相互矛盾的信息时，它会相信哪个信号？
人工智能·深度学习·算法·机器学习·目标跟踪·语言模型
BeingACoder2 小时前
【SAA】SpringAI Alibaba学习笔记（一）：SSE与WS的区别以及如何注入多个AI模型
java·笔记·学习·saa·springai
电院工程师2 小时前
SIMON64/128算法Verilog流水线实现（附Python实现）
python·嵌入式硬件·算法·密码学
轮到我狗叫了2 小时前
力扣.84柱状图中最大矩形 力扣.134加油站牛客.abb（hard 动态规划+哈希表)牛客.哈夫曼编码
算法·leetcode·职场和发展
丛雨要玩游戏3 小时前
字符函数和字符串函数
c语言·开发语言·算法
安全不再安全3 小时前
免杀技巧 - 早鸟注入详细学习笔记
linux·windows·笔记·学习·测试工具·web安全·网络安全
八个程序员3 小时前
自定义函数（C++）
开发语言·c++·算法
ad钙奶长高高3 小时前
【C语言】初始C语言
c语言·开发语言·算法
热门推荐
01GitHub 镜像站点02综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件03UV安装并设置国内源04npm使用国内淘宝镜像的方法05Linux下V2Ray安装配置指南06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07《大数据技术原理与应用》实验报告三 熟悉HBase常用操作08BongoCat - 跨平台键盘猫动画工具09NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南10GitLab 零基础入门指南：从安装到项目管理全流程