【破解C语言堆栈奥秘】实战例题解析，轻松掌握数据结构精髓

最佳答案

引言

客栈是打算机科学中一种基本的数据构造，它遵守掉落队先出（LIFO）的原则。在C言语编程中，客栈的利用非常广泛，从简单的函数挪用到复杂的算法实现，都离不开客栈的支撑。本文将经由过程实战例题剖析，帮助读者深刻懂得C言语客栈的道理与利用，轻松控制数据构造精华。

客栈基本知识

1.1 栈的定义

栈是一种线性数据构造，它支撑两种基本操纵：入栈（push）跟出栈（pop）。栈中的元素按照拔出次序陈列，最后拔出的元素开始被移除。

1.2 栈的实现

在C言语中，栈可能经由过程数组或链表实现。数组实现的栈称为次序栈，链表实现的栈称为链栈。

1.3 栈的属性

• 栈是进步后出的数据构造。
• 栈存在牢固的容量，超越容量将无法持续增加元素。
• 栈的操纵包含：初始化、入栈、出栈、断定能否为空、断定能否已满等。

次序栈的实现

次序栈利用数组实现，以下是一个简单的次序栈实现示例：

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100

typedef struct {
    int data[MAXSIZE];
    int top;
} SeqStack;

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

// 断定栈能否为空
int IsEmpty(SeqStack *s) {
    return s->top == -1;
}

// 断定栈能否满
int IsFull(SeqStack *s) {
    return s->top == MAXSIZE - 1;
}

// 入栈
void Push(SeqStack *s, int x) {
    if (IsFull(s)) {
        printf("栈满，无法入栈。\n");
        return;
    }
    s->data[++s->top] = x;
}

// 出栈
int Pop(SeqStack *s) {
    if (IsEmpty(s)) {
        return -1;
    }
    return s->data[s->top--];
}

链栈的实现

链栈利用链表实现，以下是一个简单的链栈实现示例：

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

typedef struct node {
    int data;
    struct node *next;
} LsNode;

typedef struct {
    LsNode *base;
    LsNode *top;
    int stackSize;
} LStack;

// 创建栈
LStack *CreateLsStack() {
    LStack *s = (LStack *)malloc(sizeof(LStack));
    s->base = (LsNode *)malloc(sizeof(LsNode));
    if (!s->base) {
        printf("内存分配掉败。\n");
        exit(0);
    }
    s->base->next = NULL;
    s->top = s->base;
    s->stackSize = 0;
    return s;
}

// 元素进栈
int Pus

// 初始化栈
void StackInit(ST *ps) {
    assert(ps);
    ps->arr = NULL;
    ps->capacity = ps->top = 0;
}

// 入栈
int Push(ST *ps, Datatype x) {
    if (ps->top == ps->capacity - 1) {
        return ERROR;
    }
    ps->arr[++ps->top] = x;
    return OK;
}

// 出栈
int Pop(ST *ps, Datatype *x) {
    if (ps->top == -1) {
        return ERROR;
    }
    *x = ps->arr[ps->top--];
    return OK;
}

// 烧毁栈
void StackDestroy(ST *ps) {
    free(ps->arr);
    ps->arr = NULL;
    ps->capacity = ps->top = 0;
}

实战例题剖析

例题1：实现一个函数，断定一个字符串能否为有效的括号序列。

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

#define MAXSIZE 100

typedef struct {
    char data[MAXSIZE];
    int top;
} SeqStack;

void InitStack(SeqStack *s) {
    s->top = -1;
}

int IsEmpty(SeqStack *s) {
    return s->top == -1;
}

int IsFull(SeqStack *s) {
    return s->top == MAXSIZE - 1;
}

void Push(SeqStack *s, char x) {
    if (IsFull(s)) {
        printf("栈满，无法入栈。\n");
        return;
    }
    s->data[++s->top] = x;
}

char Pop(SeqStack *s) {
    if (IsEmpty(s)) {
        return -1;
    }
    return s->data[s->top--];
}

int isValid(char *s) {
    SeqStack stack;
    InitStack(&stack);
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] == '(' || s[i] == '{' || s[i] == '[') {
            Push(&stack, s[i]);
        } else if (s[i] == ')' || s[i] == '}' || s[i] == ']') {
            if (IsEmpty(&stack)) {
                return 0;
            }
            char c = Pop(&stack);
            if ((s[i] == ')' && c != '(') || (s[i] == '}' && c != '{') || (s[i] == ']' && c != '[')) {
                return 0;
            }
        }
    }
    return IsEmpty(&stack);
}

int main() {
    char *s1 = "{[]}";
    char *s2 = "{[)]}";
    printf("s1: %s\n", isValid(s1) ? "有效" : "有效");
    printf("s2: %s\n", isValid(s2) ? "有效" : "有效");
    return 0;
}

例题2：实现一个函数，打算逆波兰表达式（后缀表达式）的值。

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

#define MAXSIZE 100

typedef struct {
    int data[MAXSIZE];
    int top;
} SeqStack;

void InitStack(SeqStack *s) {
    s->top = -1;
}

int IsEmpty(SeqStack *s) {
    return s->top == -1;
}

int IsFull(SeqStack *s) {
    return s->top == MAXSIZE - 1;
}

void Push(SeqStack *s, int x) {
    if (IsFull(s)) {
        printf("栈满，无法入栈。\n");
        return;
    }
    s->data[++s->top] = x;
}

int Pop(SeqStack *s) {
    if (IsEmpty(s)) {
        return -1;
    }
    return s->data[s->top--];
}

int precedence(char op) {
    if (op == '+' || op == '-') {
        return 1;
    } else if (op == '*' || op == '/') {
        return 2;
    }
    return 0;
}

int evaluate(char *exp) {
    SeqStack stack;
    InitStack(&stack);
    for (int i = 0; exp[i] != '\0'; i++) {
        if (isdigit(exp[i])) {
            Push(&stack, exp[i] - '0');
        } else if (exp[i] == '+' || exp[i] == '-' || exp[i] == '*' || exp[i] == '/') {
            int a = Pop(&stack);
            int b = Pop(&stack);
            int result = 0;
            switch (exp[i]) {
                case '+':
                    result = b + a;
                    break;
                case '-':
                    result = b - a;
                    break;
                case '*':
                    result = b * a;
                    break;
                case '/':
                    result = b / a;
                    break;
            }
            Push(&stack, result);
        }
    }
    return Pop(&stack);
}

int main() {
    char *exp1 = "3+5*8";
    char *exp2 = "3+5*8-2/4";
    printf("exp1: %d\n", evaluate(exp1));
    printf("exp2: %d\n", evaluate(exp2));
    return 0;
}

总结

经由过程以上实战例题剖析，信赖读者曾经对C言语客栈的道理与利用有了更深刻的懂得。在现实编程中，纯熟控制客栈数据构造，将有助于处理各种复杂成绩。