04 线性结构——栈（特性、进栈与出栈、栈顶指针、顺序栈和链式栈、相关功能的定义与代码实现）

目录

1 栈的定义

2 相关概念

2.1 栈顶（Top）

2.2 栈底（Bottom）

2.3 空栈

2.4 栈的序列

2.5 出栈入栈与栈顶指针移动的关系

2.5.1 初始情况 top = -1

2.5.2 初始情况 top = 0

3 栈的应用：函数调用

4 栈的存储结构

4.1 顺序栈

4.2 链式栈

4.2.1 头插法

4.2.2 尾插法

5 功能定义

6 功能实现

6.1 初始化栈

6.2 返回栈内元素个数

6.3 添加新元素至栈顶

6.4 弹出栈顶元素并返回

6.5 释放栈内存

6.6 遍历栈中的所有元素

6.7 完整代码 

---

1 栈的定义

        栈（stack）是一种特殊的线性表，其特点在于只能在表的一端（称为栈顶）进行插入和删除操作。栈的应用范围极为广泛，从算法设计到日常生活场景，如堆叠的盘子、报纸、电梯中人群的进出顺序、邮局的邮筒等，都体现了栈的基本思想。

        特点：栈是一种后进先出（LIFO，Last In First Out）或先进后出（FILO，First In Last Out）的线性表。这意味着最后插入的元素会最先被删除，而最先插入的元素会最后被删除。

---

2 相关概念

2.1 栈顶（Top）

        栈顶是栈中允许进行插入和删除操作的一端，也称为表尾。栈顶的位置由一个称为栈顶指针的变量来指示，该变量随着栈中元素的增减而动态变化。栈顶指针通常指向栈顶元素的下一个位置（在数组实现中）或栈顶元素本身（在链表实现中）。

2.2 栈底（Bottom）

        栈底是栈中固定不变的一端，不允许进行插入和删除操作，也称为表头。栈底通常位于栈的起始位置，其元素是栈中最早插入的元素。

2.3 空栈

        空栈是指不包含任何元素的栈。在空栈中，栈顶指针通常指向栈的起始位置或某个特定的空值标记。

2.4 栈的序列

        设栈 S = (a1, a2, ..., an)，则 a1 称为栈底元素，an 为栈顶元素。栈中元素按 a1, a2, ..., an 的次序依次进栈（压栈、push），而出栈（弹栈、pop）时，第一个被删除的元素应为栈顶元素 an，随后是 an-1, ..., a2, a1，即按照后进先出的顺序进行。

2.5 出栈入栈与栈顶指针移动的关系

        不同的参考书对栈的操作有不同的描述，以下是两种常见的描述：

2.5.1 初始情况 top = -1

        在这种情况下，栈顶指针 (top) 初始值设为 -1，表示栈为空。当有新元素入栈时，先将栈顶指针加 1（即 top++），然后将元素放入栈顶位置。出栈时，先取出栈顶元素，再将栈顶指针减 1（即 top--）。 

• 初始状态：栈为空，栈顶指针（top）为 -1。
• 元素 A 入栈：首先将栈顶指针加 1（即 top++），使得 top 变为 0，然后将元素 A 放入新的栈顶位置。
• 元素 BCD 依次入栈：同样遵循上述步骤，每次新元素进入栈时，先更新栈顶指针（top++），然后再放置元素。此时栈内顺序为 A->B->C->D，栈顶指针指向 D，top 等于 3。
• 元素 D 出栈：执行 pop 操作时，首先弹出栈顶元素 D，然后将栈顶指针下移一位（top--），指向原来的次栈顶元素 C，top 等于 2。
• 最终栈的状态变为 A->B->C，栈顶指针指向 C，top 等于 2。

2.5.2 初始情况 top = 0

        在这种情况下，栈顶指针 (top) 初始值设为 0 ，表示栈为空。当有新元素入栈时，先将元素放入栈顶位置，然后将栈顶指针加 1（即 top++）。出栈时，先将栈顶指针减 1（即 top--），再取出栈顶元素。 

• 初始状态：栈为空，栈顶指针（top）为 0。
• 元素 A 入栈：首先将元素 A 放入栈顶位置，然后将栈顶指针加 1（即 top++），使得 top 变为 1。
• 元素 BCD 依次入栈：同样遵循上述步骤，每次新元素进入栈时，先放置元素，然后再更新栈顶指针（top++）。此时栈内顺序为 A->B->C->D，栈顶指针指向 D 后面一个位置（但不存储元素）， top 等于 4。
• 元素 D 出栈：执行 pop 操作时，首先将栈顶指针下移一位，指向 C 后面一个位置（但不存储元素），即 top 变为 3，然后弹出栈顶元素 D。
• 最终栈的状态变为 A->B->C，栈顶指针指向 C 后面一个位置（但不存储元素），top 等于 3。

---

3 栈的应用：函数调用

        栈在算法和数据结构中有广泛的应用，如函数调用栈、深度优先搜索（DFS）、表达式求值、括号匹配等。此外，栈还可以用于实现队列、优先队列等其他数据结构的功能。

        栈最常用的地方就是计算机的函数调用，不管何种语言，最先被调用的函数将会最后返回，而最后被调用的函数则会最先返回其结果。举例：

void funcA() {
    funcB();
}

void funcB() {
    funcC();
}

void funcC() {
    // 执行某些操作
}

        在这个例子中，函数调用的顺序是 funcA() -> funcB() -> funcC()。当程序执行到 funcA() 时，它会调用 funcB()，而 funcB() 又会调用 funcC()。每次函数调用时，都会在调用栈上创建一个新的栈帧（或称为活动记录），用于存储该函数的局部变量、参数以及返回地址等信息。

        当 funcC() 执行完毕后，它会将控制权返回给 funcB()，后者继续执行剩余的部分，完成后也将控制权返回给 funcA()。因此，返回的顺序是 funcC() -> funcB() -> funcA()。这个过程清楚地展示了栈如何管理函数调用的顺序，确保每个函数都能正确地返回到调用它的函数处。

        通过这种方式，即使是在复杂的程序中，栈也能有效地管理和跟踪大量的函数调用，保证程序的正常运行。

---

4 栈的存储结构

        栈可以使用不同的数据结构来实现，最常见的两种方法是使用顺序表（数组）和链表。根据所使用的存储结构，栈可以分为两种类型：顺序栈和链式栈。在实际应用中，选择哪种实现方式取决于具体的需求和场景。

4.1 顺序栈

        顺序栈是使用数组来实现的栈。在这种实现方式中，栈中的元素存储在一个固定大小的数组中，通常使用一个整型变量（如 top）来指示栈顶的位置。具有以下特点：

• 存储效率高：由于使用数组，内存分配连续，访问速度快。
• 空间利用率有限：数组的大小是固定的，如果栈中元素数量超过数组的容量，需要进行扩容操作，这可能会导致额外的时间开销。
• 实现简单：数组的索引操作简单直观，易于理解和实现。

4.2 链式栈

        链式栈是使用链表来实现的栈。在这种实现方式中，栈中的元素存储在一个链表中，每个节点包含一个数据元素和一个指向下一个节点的指针。通常使用一个指针（如 top）来指示栈顶的位置。具有以下特点：

• 动态分配内存：链表的节点可以在需要时动态分配和释放，不受固定大小的限制。
• 空间利用率高：可以根据需要动态扩展和收缩，避免了空间浪费。
• 实现稍微复杂：链表的插入和删除操作涉及指针操作，相对数组来说稍微复杂一些。

4.2.1 头插法

优点：

• 插入和删除操作高效：在链表头部插入和删除节点的时间复杂度为 O(1)，因为只需要修改头指针和新节点的指针。
• 栈顶元素访问方便：栈顶元素始终位于链表的头部，可以直接通过头指针访问，无需遍历整个链表。

缺点：

• 插入和删除操作会影响其他节点：虽然头插法的时间复杂度为 O(1)，但在某些情况下，频繁的插入和删除操作可能会影响链表的稳定性，尤其是在多线程环境中。

4.2.2 尾插法

优点：

• 逻辑直观：对于习惯于从尾部操作的人来说，尾插法可能更符合直觉。

缺点：

• 插入和删除操作效率低：在链表尾部插入和删除节点的时间复杂度为 O(n)，因为每次操作都需要遍历整个链表找到最后一个节点。
• 栈顶元素访问不便：栈顶元素位于链表的尾部，访问栈顶元素需要遍历整个链表，效率较低。

总结：

        顺序栈适用于栈的大小已知且变化不大，或者对访问速度有较高要求的场景。
        链式栈适用于栈的大小不确定或频繁变化，或者需要灵活管理内存的场景。

        由于栈的主要操作是入栈（push）和出栈（pop），而这些操作都涉及到栈顶元素，因此使用头插法可以显著提高效率。头插法不仅插入和删除操作的时间复杂度为 O(1)，而且访问栈顶元素也非常方便。

---

5 功能定义

        前文提到过，栈的底层实现既可以使用数组也可以使用链表。本节基于动态数组实现一个栈，并需要实现如下函数方法：

功能	函数签名	描述
初始化栈	void initStack(Stack *stack, size_t capacity)	初始化一个栈，并设置初始容量。
返回栈内元素个数	size_t getSize(const Stack *stack)	返回栈中当前的元素个数。
添加新元素至栈顶	void push(Stack *stack, int element)	将一个新元素压入栈顶。如果栈满，则自动扩容。
弹出栈顶元素并返回	int pop(Stack *stack)	移除并返回栈顶元素（假设是 int 类型）。如果栈为空，返回错误码（如 -1）。
释放栈内存	void destroyStack(Stack *stack)	释放栈占用的所有内存资源。
遍历栈中的所有元素	void traverseStack(Stack *stack) 或 void printfStack(Stack *stack)	方法一：使用循环和一个临时栈，通过 push 和 pop 操作，遍历栈中的所有元素，遍历后栈的状态与遍历前相同。 方法二：直接通过循环动态数组的操作遍历栈中的所有元素。

---

6 功能实现

        本节基于动态数组来实现一个栈。

6.1 初始化栈

#include <stdio.h>
#include <stdlib.h>

// 定义栈结构体
// 使用顺序存储结构（动态数组）来实现 —> 顺序栈
typedef struct
{
    int *data;       // 动态数组存储栈元素,以 int 类型为例
    size_t size;     // 当前栈内元素个数
    size_t capacity; // 动态数组的容量
} Stack;

/**
 * 初始化栈
 *
 * 此函数用于初始化一个栈结构体，分配初始容量的内存，并设置栈的初始状态。
 *
 * @param stack 指向栈结构体的指针
 * @param initialCapacity 栈的初始容量
 */
void initStack(Stack *stack, size_t initialCapacity)
{
    if (stack == NULL) // 检查传入的指针是否为空
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    // size_t 是 C 标准库中定义的一种无符号整数类型，不能表示负数
    // 如果传入的 initialCapacity 是负数，可能会表示为一个很大的数（补码、数据回绕处理）
    // 函数内部不方便处理负数行为，只能在函数调用之前，约束传入的参数
    // 所以这里只是检查是否为 0
    if (initialCapacity == 0)
    {
        puts("Warning: 初始容量为 0，请使用一个正数来表示容量!");
        return; // 如果容量为 0，退出函数
    }

    // 使用 malloc 分配初始容量的内存
    stack->data = (int *)malloc(initialCapacity * sizeof(int));
    if (stack->data == NULL)
    {
        puts("Error: 内存分配失败，初始化失败!");
        return; // 如果分配失败，退出函数
    }
    stack->size = 0;                   // 初始元素个数为 0
    stack->capacity = initialCapacity; // 设置初始容量
    
    printf("Success：成功初始化动态数组，容量为：%zu\n", initialCapacity);
}

int main()
{
    // 声明结构体变量
    Stack myStack;

    puts("----------------------1.初始化栈----------------------");
    initStack(&myStack, 2); // 初始化栈，初始容量为 2
    initStack(NULL, 2);     // 错误测试
    initStack(&myStack, 0); // 错误测试

    return 0;
}

        输出结果如下所示：

6.2 返回栈内元素个数

/**
 * 获取栈内元素个数
 *
 * 此函数用于获取栈中当前的元素个数。
 *
 * @param stack 指向栈结构体的指针
 * @return 栈内元素个数，如果传入的指针为 NULL，则返回 0
 */
size_t getSize(const Stack *stack)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return 0; // 如果是空指针，返回 0
    }

    // 返回栈内元素个数
    return stack->size;
}

6.3 添加新元素至栈顶

/**
 * 添加新元素到栈顶
 *
 * 此函数用于将新元素添加到栈顶。如果栈已满，会自动扩展栈的容量。
 * 新元素只能添加到栈顶(即动态数组的尾部)，所以不用传入索引。
 *
 * @param stack 指向栈结构体的指针
 * @param element 要添加的新元素
 */
void push(Stack *stack, int element)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    // 检查顺序表(动态数组)是否存满了
    if (stack->size == stack->capacity)
    {
        printf("栈空间已满，当前容量为 %zu ，需要扩容，正在扩容中~\n", stack->capacity);
        // 如果栈已满，需要扩展容量
        size_t newCapacity = stack->capacity * 2; // 扩容到原来的 2 倍
        // 重新分配内存
        int *newData = (int *)realloc(stack->data, newCapacity * sizeof(int));

        if (newData == NULL)
        {
            puts("Error: 扩容失败!");
            return; // 如果内存分配失败，退出函数
        }

        stack->data = newData;
        stack->capacity = newCapacity;
        printf("扩容成功(容量扩大一倍)，现在的容量为 %zu\n", newCapacity);
    }

    stack->data[stack->size] = element; // 将元素压入栈顶
    stack->size++;                      // 更新元素个数
    printf("Success：新元素 %d 成功进栈(栈顶)\n", element);
}

6.4 弹出栈顶元素并返回

/**
 * 弹出栈顶元素并返回
 *
 * 此函数用于从栈顶弹出一个元素，并返回该元素。如果栈为空，会输出错误信息并返回一个无效值。
 *
 * @param stack 指向栈结构体的指针
 * @return 栈顶元素，如果栈为空则返回 -1
 */
int pop(Stack *stack)
{
    // 检查栈是否为空
    if (stack->size == 0)
    {
        puts("当前栈空，弹栈失败");
        return -1; // 栈为空，返回无效值
    }

    // 方法 1
    // int popElement = stack->data[stack->size - 1]; // 使用数组加下标返回，注意需要 -1 ，不然会越界访问
    // stack->size--;                                 // 更新元素个数
    // return popElement;

    // 方法 2
    // stack->size--;                   // 更新元素个数
    // return stack->data[stack->size]; // 返回栈顶元素

    // 方法 3
    return stack->data[--stack->size]; // 返回栈顶元素并更新元素个数(自减操作)
}

6.5 释放栈内存

/**
 * 释放栈内存
 *
 * 此函数用于释放栈所占用的内存，并将栈结构体的成员重置为初始状态。
 *
 * @param stack 指向栈结构体的指针
 */
void destroyStack(Stack *stack)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    // 释放动态数组内存
    free(stack->data);  // 释放动态数组内存
    stack->data = NULL; // 防止悬挂指针

    // 重置栈结构体的成员
    stack->size = 0;
    stack->capacity = 0;

    puts("Success: 栈内存已成功释放");
}

6.6 遍历栈中的所有元素

/**
 * 遍历栈中的所有元素
 *
 * 此函数用于遍历栈中的所有元素，打印每个元素的值。遍历后栈的状态与遍历前相同。
 *
 * @param stack 指向栈结构体的指针
 */
void traverseStack(Stack *stack)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    Stack tempStack;                        // 创建一个临时栈用于保存弹出的元素
    initStack(&tempStack, stack->capacity); // 初始化临时栈，容量与原栈相同

    puts("使用临时栈的方式遍历栈栈中的所有元素：");

    // 循环直到原栈为空
    while (stack->size > 0)
    {
        int element = pop(stack);  // 从原栈弹出元素
        printf("%d\t", element);   // 处理元素（这里是打印）
        push(&tempStack, element); // 将元素压入临时栈
    }
    printf("\n");

    // 将所有元素从临时栈重新压入原栈
    while (tempStack.size > 0)
    {
        int element = pop(&tempStack); // 从临时栈弹出元素
        push(stack, element);          // 将元素压回原栈
    }

    // 释放临时栈占用的资源
    destroyStack(&tempStack);
}

        对于顺序栈，可以直接使用循环遍历动态数组进行栈元素的访问，如下所示：

/**
 * 打印栈中的所有元素
 *
 * 此函数用于打印栈中的所有元素。通过直接访问栈的内部数组，从栈底到栈顶依次打印每个元素。
 *
 * @param stack 指向栈结构体的指针
 */
void printfStack(Stack *stack)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    // 检查栈是否为空
    if (stack->size == 0)
    {
        puts("Warning：当前栈为空，没有元素可以打印");
        return; // 如果栈为空，直接返回
    }

    for (size_t i = 0; i < stack->size; i++)
    {
        printf("%d\t", stack->data[i]); // 打印每个元素，使用制表符分隔
    }

    // 注意，倒着遍历的时候，就不能使用 size_t 定义循环变量
    // size_t 无法取到负数，会将负数（计算机中存储的是补码）解释成一个很大的数
    // 所以得用 int 定义循环变量
    // for (int i = stack->size - 1; i >= 0; i--)
    // {
    //     printf("%d\t", stack->data[i]); // 打印每个元素，使用制表符分隔
    // }
    printf("\n"); // 打印一个换行，结束一行
}

6.7 完整代码 

#include <stdio.h>
#include <stdlib.h>

// 定义栈结构体
// 使用顺序存储结构（动态数组）来实现 —> 顺序栈
typedef struct
{
    int *data;       // 动态数组存储栈元素,以 int 类型为例
    size_t size;     // 当前栈内元素个数
    size_t capacity; // 动态数组的容量
} Stack;

/**
 * 初始化栈
 *
 * 此函数用于初始化一个栈结构体，分配初始容量的内存，并设置栈的初始状态。
 *
 * @param stack 指向栈结构体的指针
 * @param initialCapacity 栈的初始容量
 */
void initStack(Stack *stack, size_t initialCapacity)
{
    if (stack == NULL) // 检查传入的指针是否为空
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    // size_t 是 C 标准库中定义的一种无符号整数类型，不能表示负数
    // 如果传入的 initialCapacity 是负数，可能会表示为一个很大的数（补码、数据回绕处理）
    // 函数内部不方便处理负数行为，只能在函数调用之前，约束传入的参数
    // 所以这里只是检查是否为 0
    if (initialCapacity == 0)
    {
        puts("Warning: 初始容量为 0，请使用一个正数来表示容量!");
        return; // 如果容量为 0，退出函数
    }

    // 使用 malloc 分配初始容量的内存
    stack->data = (int *)malloc(initialCapacity * sizeof(int));
    if (stack->data == NULL)
    {
        puts("Error: 内存分配失败，初始化失败!");
        return; // 如果分配失败，退出函数
    }
    stack->size = 0;                   // 初始元素个数为 0
    stack->capacity = initialCapacity; // 设置初始容量

    printf("Success：成功初始化动态数组，容量为：%zu\n", initialCapacity);
}

/**
 * 获取栈内元素个数
 *
 * 此函数用于获取栈中当前的元素个数。
 *
 * @param stack 指向栈结构体的指针
 * @return 栈内元素个数，如果传入的指针为 NULL，则返回 0
 */
size_t getSize(const Stack *stack)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return 0; // 如果是空指针，返回 0
    }

    // 返回栈内元素个数
    return stack->size;
}

/**
 * 添加新元素到栈顶
 *
 * 此函数用于将新元素添加到栈顶。如果栈已满，会自动扩展栈的容量。
 * 新元素只能添加到栈顶(即动态数组的尾部)，所以不用传入索引。
 *
 * @param stack 指向栈结构体的指针
 * @param element 要添加的新元素
 */
void push(Stack *stack, int element)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    // 检查顺序表(动态数组)是否存满了
    if (stack->size == stack->capacity)
    {
        printf("栈空间已满，当前容量为 %zu ，需要扩容，正在扩容中~\n", stack->capacity);
        // 如果栈已满，需要扩展容量
        size_t newCapacity = stack->capacity * 2; // 扩容到原来的 2 倍
        // 重新分配内存
        int *newData = (int *)realloc(stack->data, newCapacity * sizeof(int));

        if (newData == NULL)
        {
            puts("Error: 扩容失败!");
            return; // 如果内存分配失败，退出函数
        }

        stack->data = newData;
        stack->capacity = newCapacity;
        printf("扩容成功(容量扩大一倍)，现在的容量为 %zu\n", newCapacity);
    }

    stack->data[stack->size] = element; // 将元素压入栈顶
    stack->size++;                      // 更新元素个数
    printf("Success：新元素 %d 成功进栈(栈顶)\n", element);
}

/**
 * 弹出栈顶元素并返回
 *
 * 此函数用于从栈顶弹出一个元素，并返回该元素。如果栈为空，会输出错误信息并返回一个无效值。
 *
 * @param stack 指向栈结构体的指针
 * @return 栈顶元素，如果栈为空则返回 -1
 */
int pop(Stack *stack)
{
    // 检查栈是否为空
    if (stack->size == 0)
    {
        puts("当前栈空，弹栈失败");
        return -1; // 栈为空，返回无效值
    }

    // 方法 1
    // int popElement = stack->data[stack->size - 1]; // 使用数组加下标返回，注意需要 -1 ，不然会越界访问
    // stack->size--;                                 // 更新元素个数
    // return popElement;

    // 方法 2
    // stack->size--;                   // 更新元素个数
    // return stack->data[stack->size]; // 返回栈顶元素

    // 方法 3
    return stack->data[--stack->size]; // 返回栈顶元素并更新元素个数(自减操作)
}

/**
 * 释放栈内存
 *
 * 此函数用于释放栈所占用的内存，并将栈结构体的成员重置为初始状态。
 *
 * @param stack 指向栈结构体的指针
 */
void destroyStack(Stack *stack)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    // 释放动态数组内存
    free(stack->data);  // 释放动态数组内存
    stack->data = NULL; // 防止悬挂指针

    // 重置栈结构体的成员
    stack->size = 0;
    stack->capacity = 0;

    puts("Success: 栈内存已成功释放");
}

/**
 * 遍历栈中的所有元素
 *
 * 此函数用于遍历栈中的所有元素，打印每个元素的值。遍历后栈的状态与遍历前相同。
 *
 * @param stack 指向栈结构体的指针
 */
void traverseStack(Stack *stack)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    Stack tempStack;                        // 创建一个临时栈用于保存弹出的元素
    initStack(&tempStack, stack->capacity); // 初始化临时栈，容量与原栈相同

    puts("使用临时栈的方式遍历栈栈中的所有元素：");

    // 循环直到原栈为空
    while (stack->size > 0)
    {
        int element = pop(stack);  // 从原栈弹出元素
        printf("%d\t", element);   // 处理元素（这里是打印）
        push(&tempStack, element); // 将元素压入临时栈
    }
    printf("\n");

    // 将所有元素从临时栈重新压入原栈
    while (tempStack.size > 0)
    {
        int element = pop(&tempStack); // 从临时栈弹出元素
        push(stack, element);          // 将元素压回原栈
    }

    // 释放临时栈占用的资源
    destroyStack(&tempStack);
}

/**
 * 打印栈中的所有元素
 *
 * 此函数用于打印栈中的所有元素。通过直接访问栈的内部数组，从栈底到栈顶依次打印每个元素。
 *
 * @param stack 指向栈结构体的指针
 */
void printfStack(Stack *stack)
{
    // 检查传入的指针是否为空
    if (stack == NULL)
    {
        puts("Error: 传入的栈为 NULL");
        return; // 如果是空指针，则直接返回，退出函数
    }

    // 检查栈是否为空
    if (stack->size == 0)
    {
        puts("Warning：当前栈为空，没有元素可以打印");
        return; // 如果栈为空，直接返回
    }

    for (size_t i = 0; i < stack->size; i++)
    {
        printf("%d\t", stack->data[i]); // 打印每个元素，使用制表符分隔
    }

    // 注意，倒着遍历的时候，就不能使用 size_t 定义循环变量
    // size_t 无法取到负数，会将负数（计算机中存储的是补码）解释成一个很大的数
    // 所以得用 int 定义循环变量
    // for (int i = stack->size - 1; i >= 0; i--)
    // {
    //     printf("%d\t", stack->data[i]); // 打印每个元素，使用制表符分隔
    // }
    printf("\n"); // 打印一个换行，结束一行
}

int main()
{
    // 声明结构体变量
    Stack myStack;

    puts("----------------------1.初始化栈----------------------");
    initStack(&myStack, 2); // 初始化栈，初始容量为 2
    initStack(NULL, 2);     // 错误测试
    initStack(&myStack, 0); // 错误测试

    puts("-------------------2.新元素进栈(栈顶)------------------");
    push(NULL, 1);     // 错误测试
    push(&myStack, 1); // 元素 1 压栈
    push(&myStack, 2); // 元素 2 压栈
    push(&myStack, 3); // 元素 3 压栈(需要扩容)
    printf("栈内元素个数为：%zu\n", getSize(&myStack));
    printf("栈内元素个数为：%zu\n", getSize(NULL)); // 错误测试 返回 0

    puts("---------------------3.循环遍历栈元素--------------------");
    // traverseStack(&myStack);
    printfStack(&myStack);
    printfStack(NULL); // 错误测试

    puts("---------------------4.栈顶元素出栈--------------------");
    printf("弹出的栈顶元素是：%d\n", pop(&myStack));
    printf("弹出的栈顶元素是：%d\n", pop(&myStack));
    printf("弹出的栈顶元素是：%d\n", pop(&myStack));
    printf("栈内元素个数为：%zu\n", getSize(&myStack));
    printfStack(&myStack); // 没有元素可打印，警告

    puts("---------------------4.释放栈内存--------------------");
    destroyStack(&myStack);

    return 0;
}

        输出结果如下所示：