数据结构之顺序栈：严蔚敏C语言实现详解

本文还有配套的精品资源，点击获取

简介：数据结构是计算机科学核心课程，专注于数据的有效存储和操作。栈是数据结构中的基础，其后进先出（LIFO）特性使得它在算法实现中非常重要。顺序栈是栈的一种实现，通过数组在内存中连续存储数据。C语言中顺序栈的实现包括元素的压栈、弹栈和查看栈顶元素等操作。本教程详细介绍了严蔚敏教授的顺序栈实现方法，包括栈的定义、初始化、操作方法和错误处理等。教程以实例和习题帮助读者深入理解并掌握顺序栈的概念与应用，适合作为初学者和专业程序员的学习和参考资源。

1. 数据结构基础介绍

数据结构是计算机科学与软件工程领域中存储、组织数据的一种方式，它使得数据的查询、插入、删除和修改等操作变得更加高效。本章节将介绍数据结构的基本概念，为后续章节的深入学习打下坚实的基础。

数据结构通常可以分为两大类：线性结构和非线性结构。线性结构包括数组、链表、栈、队列等，它们的数据元素之间存在一对一的关系；非线性结构如树、图等，它们的数据元素之间存在一对多或多对多的关系。学习和理解这些结构能够帮助开发者高效处理数据，优化程序性能。

在本章中，我们将从数据结构的定义、特点和分类讲起，逐步过渡到它在算法设计和程序开发中的实际应用，以及为何数据结构对提高数据处理效率至关重要。随着内容的推进，我们将进一步探索数据结构在真实世界的场景应用，为读者提供一个全面且实用的视角。

2. 栈（LIFO）数据结构概念

2.1 栈的定义和特性

2.1.1 栈的抽象数据类型定义

栈是一种后进先出（Last In First Out，LIFO）的数据结构，它模拟了一种特定类型的集合，其中元素的添加（入栈）和删除（出栈）操作仅限于同一端，称为栈顶。这种数据结构限制了集合的存取方式，使得最后进入的数据可以最先被访问和移除，这与生活中的堆叠盘子的类比相似。一个栈可以被定义为以下抽象数据类型：

• push(value) ：向栈顶添加一个元素。
• pop() ：移除并返回栈顶元素。
• peek() 或 top() ：返回栈顶元素但不移除它。
• isEmpty() ：判断栈是否为空。
• size() ：返回栈中的元素数量。

由于栈只允许在一端进行操作，这使得栈非常适合处理具有自然的LIFO属性的问题，如括号匹配、函数调用栈、撤销操作、后序遍历等。

2.1.2 栈操作的基本规则

栈的操作规则很简单但很重要，它定义了如何对栈进行各种操作。以下是栈的基本操作规则：

• LIFO规则 ：最后添加到栈上的元素会是第一个被移除的元素。这一规则是栈的核心特性，也是栈之所以特别的原因。
• 栈顶规则 ：所有元素的添加和移除操作都发生在栈顶。栈底通常固定不动，所有的入栈和出栈操作都围绕着栈顶进行。
• 访问规则 ：只能访问栈顶元素。在任何时刻，栈的内部状态只允许我们查看或操作栈顶的元素。
• 修改规则 ：在非空栈上执行pop操作会移除栈顶元素。在空栈上执行pop操作是不允许的，通常会返回一个错误或异常。
• 容量规则 ：栈可以具有固定容量或动态调整容量。固定容量栈在达到最大容量时无法添加新元素，动态容量栈则可以通过扩容来继续添加元素。

2.1.3 栈的数据结构图示

为了更直观地理解栈的概念，我们可以用一个简单的图示来展示栈的结构和操作：

栈顶
+------+
|  A   | <--- Push 'A'
+------+
|  B   | <--- Push 'B'
+------+
|  C   | <--- Push 'C'
+------+
|      | <--- Top element is 'C'
+------+

2.2 栈在计算机科学中的应用

2.2.1 栈与递归算法

递归算法是函数调用自身解决问题的一种编程技术。在递归算法的执行过程中，每一次函数调用都会在调用栈上创建一个新的栈帧，包含函数的局部变量和执行状态。当函数执行完毕后，栈帧被销毁，控制权返回给调用它的函数。由于栈的LIFO特性，递归函数的栈帧可以被有效地管理，这使得栈成为实现递归算法的关键组件。

int factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

在上述示例中，每次调用 factorial 函数都会将新的 n 值压入栈中，当 n 值到达基础情况时，递归调用开始回溯，栈帧按相反的顺序弹出，计算得到最终结果。

2.2.2 栈在表达式求值中的作用

表达式求值是栈在计算机科学中的另一个典型应用场景。特别是对于中缀表达式向后缀（逆波兰表示法）或前缀表达式的转换，栈提供了一种非常自然和高效的方法。这主要利用了栈的后进先出特性。

在将中缀表达式转换为后缀表达式的算法中，遇到操作数时直接输出，遇到运算符时与栈顶运算符比较优先级，如果优先级低则输出栈顶运算符，然后将当前运算符压栈；如果优先级高或栈为空，则直接将当前运算符压栈。遍历完表达式后，将栈内剩余的运算符依次输出。

以表达式 (3 + 4) * 5 的后缀转换为例：

1. 遇到左括号 ( ，压入栈。
2. 遇到数字 3 ，输出。
3. 遇到 + ，压入栈。
4. 遇到数字 4 ，输出。
5. 遇到右括号 ) ，依次弹出 + 和 ( 并输出，括号内的表达式处理完毕。
6. 遇到 * ，因为栈为空，直接压入栈。
7. 遇到数字 5 ，输出。
8. 表达式遍历完成，将栈内剩余运算符 * 输出。

以上过程中，栈的使用使得表达式的运算符可以按照正确的顺序进行输出，从而达到正确转换表达式的目的。

3. 顺序栈定义和实现

在数据结构的学习过程中，顺序栈是一种基础而又重要的数据结构，其设计理念和实现方式为解决实际问题提供了有效的工具。本章节将详细介绍顺序栈的理论模型以及其基本操作原理。

3.1 顺序栈的理论模型

顺序栈作为一种线性表的特殊形式，采用了后进先出（LIFO）的原则，确保了在任何时刻只有最后一个插入的元素可以被首先访问和删除。顺序栈的逻辑结构简单而严格，是计算机科学中重要的概念之一。

3.1.1 数据结构中顺序栈的概念框架

顺序栈在内存中的表现形式通常是数组。栈中每个元素在数组中的位置是固定的，我们称栈底为数组的起始位置，而栈顶则是数组中最后被插入的元素的位置。在顺序栈中，除了数据元素的值，最重要的信息就是栈顶指针的位置，它标识了栈顶元素所在的位置，进而能够确定栈中元素的数量。

3.1.2 顺序栈的数学模型与逻辑结构

从数学角度来讲，我们可以将顺序栈看作是一个有序的n元组 (a1, a2, ..., an)，其中，ai表示栈中第i个元素的值。在逻辑上，我们通常使用一个变量top来表示栈顶的位置，top初始值设为0表示一个空栈，每当有新的元素入栈，top增加，每当元素出栈，top减少。在顺序栈的实现中，我们还需确保top的值永远不会超出数组的范围，以避免数组越界错误。

3.2 顺序栈的基本操作原理

顺序栈作为一种抽象数据类型，其主要的操作包括入栈（push）、出栈（pop）、查看栈顶元素（peek）和检查栈是否为空或满。我们将在下面详细探讨这些操作的原理和实现。

3.2.1 栈内元素存储和管理机制

在顺序栈的实现中，元素的存储完全依赖于数组的连续内存空间。这使得栈操作的逻辑非常简单且执行效率高。所有栈内的元素都按照插入的逆序排列，即后进入的元素排在数组的高索引位置。

3.2.2 栈顶指针的作用与变化规律

栈顶指针是顺序栈实现的核心。在不同的操作下，栈顶指针会发生相应的改变： - 入栈操作（push）：将元素添加到栈顶指针所指的位置，然后栈顶指针加一。 - 出栈操作（pop）：从栈顶指针所指的位置移除元素，然后栈顶指针减一。 - 查看栈顶元素（peek）：获取栈顶指针所指位置的元素，但不改变栈顶指针的值。 - 检查栈是否为空或满：通常通过栈顶指针的值来判断，如果栈顶指针等于0，则栈为空；如果栈顶指针等于数组的最大索引，则栈为满。

代码实现示例

在C语言中，顺序栈可以通过结构体和数组实现。下面是一个简单的示例：

#define MAX_SIZE 100 // 定义顺序栈的最大容量

// 顺序栈的结构体定义
typedef struct {
    int data[MAX_SIZE]; // 存储栈元素的数组
    int top;            // 栈顶指针
} SeqStack;

// 初始化栈
void initStack(SeqStack *s) {
    s->top = -1; // 初始化栈顶指针为-1，表示栈为空
}

// 入栈操作
bool push(SeqStack *s, int element) {
    if (s->top >= MAX_SIZE - 1) { // 栈满，无法添加
        return false;
    }
    s->data[++s->top] = element; // 先增加栈顶指针，再添加元素
    return true;
}

// 出栈操作
bool pop(SeqStack *s, int *element) {
    if (s->top == -1) { // 栈空，无法移除
        return false;
    }
    *element = s->data[s->top--]; // 先取出元素，再减少栈顶指针
    return true;
}

// 查看栈顶元素
bool peek(SeqStack *s, int *element) {
    if (s->top == -1) { // 栈空，无元素可查看
        return false;
    }
    *element = s->data[s->top]; // 直接获取栈顶元素
    return true;
}

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

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

表格：顺序栈操作对比

| 操作 | 时间复杂度 | 空间复杂度 | 描述 | | --- | --- | --- | --- | | push | O(1) | O(1) | 将元素添加到栈顶 | | pop | O(1) | O(1) | 从栈顶移除元素 | | peek | O(1) | O(1) | 查看栈顶元素但不移除 | | isEmpty | O(1) | O(1) | 检查栈是否为空 | | isFull | O(1) | O(1) | 检查栈是否已满 |

通过以上代码和表格的展示，我们可以看到顺序栈的内部操作机制以及如何在实际中通过代码来实现这些基本功能。顺序栈的这些特性使得它成为算法设计和程序开发中不可或缺的工具。

4. C语言实现顺序栈

在上一章节中，我们讨论了顺序栈的理论模型和基本操作原理。现在，我们将进入实践环节，用C语言来实现一个顺序栈。通过本章节，读者将了解C语言数组的基础知识，并掌握如何使用C语言来定义和实现顺序栈。

4.1 C语言数组基础

4.1.1 数组定义和内存布局

在C语言中，数组是用于存储一系列相同类型元素的复合数据类型。数组的定义非常直观：

type arrayName[arraySize];

其中， type 是数组中元素的类型， arrayName 是数组的名称， arraySize 指定了数组可以存储的元素数量。

数组在内存中的布局是连续的，这意味着数组的元素在物理内存中是相邻的。这种连续的内存布局对于通过索引直接访问数组元素提供了便利，但同时也意味着数组的大小一旦确定就无法改变。

4.1.2 数组与顺序存储结构的关系

顺序存储结构是指数据元素在内存中连续存放的存储结构。数组正是这种存储方式的体现，因此数组是实现顺序栈的理想选择。顺序栈中元素的添加和删除都发生在同一端（栈顶），因此顺序存储结构能够高效地满足这一需求。

4.1.3 C语言数组操作

数组的访问通常通过下标操作符[]完成，如下所示：

int myArray[10];
myArray[0] = 5; // 将第一个元素设置为5
int value = myArray[0]; // 读取第一个元素的值

数组的遍历也十分常见，可以通过循环来访问数组中的每一个元素：

for (int i = 0; i < 10; i++) {
    printf("%d ", myArray[i]);
}

4.2 使用C语言实现顺序栈

4.2.1 顺序栈的C语言数据结构定义

顺序栈可以用一个结构体来表示，其中包含一个数组用于存储栈的元素，以及一个整型变量来跟踪栈顶的位置。

#define MAX_SIZE 100 // 定义栈的最大容量

typedef struct {
    int items[MAX_SIZE]; // 存储栈内元素的数组
    int top; // 栈顶指针
} Stack;

4.2.2 栈操作函数的C语言实现

接下来，我们将实现顺序栈的基本操作，包括初始化栈、检查栈是否为空、检查栈是否已满、入栈、出栈、获取栈顶元素等。

. . . 初始化栈

初始化栈意味着将栈顶指针 top 设置为-1，表明栈为空：

void initializeStack(Stack *stack) {
    stack->top = -1;
}

. . . 检查栈是否为空

如果栈顶指针 top 为-1，则表示栈为空：

int isStackEmpty(Stack *stack) {
    return stack->top == -1;
}

. . . 检查栈是否已满

在尝试添加新元素之前，需要检查栈是否已满：

int isStackFull(Stack *stack) {
    return stack->top == MAX_SIZE - 1;
}

. . . 入栈操作

入栈（push）操作是在栈顶添加一个新元素：

void push(Stack *stack, int item) {
    if (isStackFull(stack)) {
        // 栈满时无法添加新元素
        printf("Stack is full\n");
    } else {
        stack->items[++stack->top] = item;
    }
}

. . . 出栈操作

出栈（pop）操作是从栈顶移除一个元素：

int pop(Stack *stack) {
    if (isStackEmpty(stack)) {
        // 栈空时无法移除元素
        printf("Stack is empty\n");
        return -1;
    } else {
        return stack->items[stack->top--];
    }
}

. . . 获取栈顶元素

有时我们需要获取栈顶元素的值而不从栈中移除它：

int peek(Stack *stack) {
    if (!isStackEmpty(stack)) {
        return stack->items[stack->top];
    }
    printf("Stack is empty\n");
    return -1;
}

4.2.3 编程实例演示顺序栈的应用

下面的实例演示了如何使用我们刚实现的顺序栈结构：

int main() {
    Stack stack;
    initializeStack(&stack);

    push(&stack, 10);
    push(&stack, 20);
    push(&stack, 30);

    printf("Top element is %d\n", peek(&stack));

    while (!isStackEmpty(&stack)) {
        printf("Popped: %d\n", pop(&stack));
    }

    if (isStackEmpty(&stack)) {
        printf("Stack is now empty\n");
    }

    return 0;
}

这段代码展示了顺序栈的初始化、入栈、查看栈顶元素、出栈以及检查栈是否为空的操作。通过实际代码的演示，我们可以看到顺序栈操作的具体应用，从而更好地理解其在程序中的作用。

通过本章节的讲解，读者现在应该能够理解顺序栈的概念，并且能够使用C语言来实现顺序栈的各个操作。在下一章，我们将讨论顺序栈的高级操作和应用。

5. 顺序栈的高级操作与应用

5.1 顺序栈的动态管理

在前面的章节中，我们已经了解了顺序栈的基本概念和实现。为了使顺序栈更加通用和高效，我们需要对顺序栈进行动态管理，包括初始化、扩容和缩容机制。

5.1.1 栈的初始化

顺序栈的初始化是创建一个空栈的过程。在C语言中，可以通过分配数组空间和初始化栈顶指针来完成初始化。这里是一个简单的示例：

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

#define MAXSIZE 10 // 定义栈的最大容量

typedef struct {
    int data[MAXSIZE]; // 存储栈内元素的数组
    int top; // 栈顶指针，-1 表示空栈
} SeqStack;

// 初始化栈
void InitStack(SeqStack *s) {
    s->top = -1; // 栈顶指针初始化为 -1，表示栈为空
}

5.1.2 栈的扩容与缩容机制

为了应对栈空间不足的情况，我们需要实现扩容机制。同样，为了优化内存使用，我们也需要实现缩容机制。

// 栈扩容函数
void StackResize(SeqStack *s, int newSize) {
    int *temp = (int *)realloc(s->data, sizeof(int) * newSize);
    if (temp != NULL) {
        s->data = temp;
        s->top = (s->top < newSize - 1) ? s->top : newSize - 1; // 更新栈顶指针
    } else {
        printf("Memory reallocation failed.\n");
        exit(1);
    }
}

// 栈缩容函数
void StackShrink(SeqStack *s, int newMaxSize) {
    if (newMaxSize >= s->top) {
        StackResize(s, newMaxSize);
    }
}

5.2 顺序栈操作的边界处理

顺序栈操作中，对栈满和栈空的判断逻辑是十分重要的。此外，错误处理和异常管理也是必须考虑的。

5.2.1 栈满与栈空的判断逻辑

在顺序栈中，栈满的条件是栈顶指针等于最大索引位置（即 top == MAXSIZE - 1 ），而栈空的条件是栈顶指针为 -1 。

// 检查栈是否已满
int IsFull(SeqStack *s) {
    return s->top == MAXSIZE - 1;
}

// 检查栈是否为空
int IsEmpty(SeqStack *s) {
    return s->top == -1;
}

5.2.2 错误处理和异常管理

在任何数据结构的操作中，错误处理和异常管理都是不可或缺的。它们确保程序的健壮性和稳定性。

// 入栈操作，包括错误处理
void Push(SeqStack *s, int element) {
    if (IsFull(s)) {
        StackResize(s, 2 * MAXSIZE); // 扩容策略：扩容为原来的两倍
    }
    s->data[++s->top] = element; // 元素入栈
}

// 出栈操作，包括错误处理
int Pop(SeqStack *s) {
    if (IsEmpty(s)) {
        printf("Stack is empty!\n");
        return -1; // 返回错误码
    }
    return s->data[s->top--]; // 返回栈顶元素并出栈
}

5.3 顺序栈在编程实践中的应用

顺序栈在编程中的应用非常广泛，接下来，我们将通过封装函数和具体实例来演示顺序栈的实际应用。

5.3.1 函数封装提高代码复用

为了提高代码的复用性和可维护性，我们将栈操作封装为函数。以下是一些封装好的函数：

// 入栈
void Push(SeqStack *s, int element) {
    if (IsFull(s)) {
        StackResize(s, 2 * MAXSIZE);
    }
    s->data[++s->top] = element;
}

// 出栈
int Pop(SeqStack *s) {
    if (IsEmpty(s)) {
        printf("Stack is empty!\n");
        return -1;
    }
    return s->data[s->top--];
}

// 查看栈顶元素
int GetTop(SeqStack *s) {
    if (IsEmpty(s)) {
        printf("Stack is empty!\n");
        return -1;
    }
    return s->data[s->top];
}

5.3.2 编程实例演示顺序栈的应用

最后，我们将通过一个实例来演示顺序栈的应用。假设我们需要使用顺序栈来计算一个数的阶乘：

#include <stdio.h>

int main() {
    SeqStack s;
    InitStack(&s);

    int number = 5;
    int factorial = 1;

    // 计算阶乘
    for (int i = 1; i <= number; i++) {
        Push(&s, i);
        factorial *= i;
    }

    printf("Factorial of %d is %d\n", number, factorial);

    // 清空栈并释放内存
    while (!IsEmpty(&s)) {
        Pop(&s);
    }

    return 0;
}

以上章节内容展示了顺序栈的高级操作，包括动态管理、边界处理，以及在编程实践中的应用。顺序栈的这些高级用法使其在实际问题解决中变得更加灵活和强大。

本文还有配套的精品资源，点击获取

简介：数据结构是计算机科学核心课程，专注于数据的有效存储和操作。栈是数据结构中的基础，其后进先出（LIFO）特性使得它在算法实现中非常重要。顺序栈是栈的一种实现，通过数组在内存中连续存储数据。C语言中顺序栈的实现包括元素的压栈、弹栈和查看栈顶元素等操作。本教程详细介绍了严蔚敏教授的顺序栈实现方法，包括栈的定义、初始化、操作方法和错误处理等。教程以实例和习题帮助读者深入理解并掌握顺序栈的概念与应用，适合作为初学者和专业程序员的学习和参考资源。

本文还有配套的精品资源，点击获取