「数据结构四」C 语言实现栈

2017-05-09 本文已影响33人 Barry_1

栈（stack）是限定在表尾进行插入或删除操作的线性表。因此，栈的表尾端具有特殊的含义，称为栈顶（top），相对应，表头端的称为栈底（bottom）。

为什么称之为特殊的线性表，它的特殊之处在于只能允许在栈的顶端加入数据（push）和输出数据（pop）。由于它是特殊的线性表，所以我们可以实现顺序结构的栈和链式结构的栈。

顺序栈

顺序栈是指利用顺序存储结构实现的栈，即利用一组地址连续的存储单元一次存放自栈底到栈顶的数据元素，同时设置 top 指针指向栈顶元素。

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

#define STACK_INIT_SIZE 100
#define STACK_INCREMENT 2

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define INFEASIBLE 0

typedef int Status;
typedef int SElemType;

typedef struct {
    SElemType *base;  //栈底指针
    SElemType *top;  //栈顶指针
    int stackSize;
}SqStack;

Status InitStack(SqStack *S);
Status DestroyStack(SqStack *S);
Status ClearStack(SqStack *S);
Status StackEmpty(SqStack S);
int StackLength(SqStack S);
Status GetTop(SqStack S, SElemType *e);
Status Push(SqStack *S, SElemType e);
Status Pop(SqStack *S, SElemType *e);
Status StackTraverse(SqStack S, void(*vi)(SElemType));

/**
 * 操作结果：构造一个空栈 S。
 * @param S
 * @return
 */
Status InitStack(SqStack *S) {
    S->base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SqStack));  //开辟内存空间
    if (!S->base) {
        exit(OVERFLOW);  //开辟失败
    }
    S->top = S->base;
    S->stackSize = STACK_INIT_SIZE;
    return OK;
}

/**
 * 初始条件：栈 S 存在
 * 操作结果：栈 S 被销毁
 * @param S
 * @return
 */
Status DestroyStack(SqStack *S) {
    if (S->base) {
        free(S->base);  //释放栈底指针内存空间
    }
    S->top = S->base = NULL;  //栈底栈顶指针置为 NULL
    S->stackSize = 0;
    return OK;
}

/**
 * 初始条件：栈 S 存在
 * 操作结果：将栈 S 清为空栈
 * @param S
 * @return
 */
Status ClearStack(SqStack *S) {
    S->top = S->base;
    return OK;
}

/**
 * 初始条件：栈 S 存在
 * 操作结果：若 S 为空栈，返回 true，否则返回 false
 * @param S
 * @return
 */
Status StackEmpty(SqStack S) {
    if (S.top == S.base) {
        return TRUE;
    } else {
        return FALSE;
    }
}

/**
 * 初始条件：栈 S 存在
 * 操作结果：返回 S 中元素的个数，即栈的长度
 * @param S
 * @return
 */
int StackLength(SqStack S) {
    return (int) (S.top - S.base);
}

/**
 * 初始条件：栈 S 存在且非空
 * 操作结果：返回栈顶元素，不修改栈顶指针
 * @param S
 * @return
 */
Status GetTop(SqStack S, SElemType *e) {
    if (S.top != S.base) {
        *e = *(S.top - 1);
        return OK;
    }
    return ERROR;

}

/**
 * 初始条件：栈 S 存在
 * 操作结果：插入元素 e 为新的栈顶元素
 * @param S
 * @param e
 * @return
 */
Status Push(SqStack *S, SElemType e) {
    if ((S->top - S->base) >= S->stackSize) { //判读栈是否满
        S->base = (SElemType *)realloc(S->base, (S->stackSize + STACK_INCREMENT) * sizeof(SqStack));
        if (!S->base) {
            return ERROR;
        }
        S->top = S->base + S->stackSize;
        S->stackSize += STACK_INCREMENT;
    }
    *S->top++ = e;
    return OK;
}

/**
 * 初始条件：栈 S 存在且非空
 * 操作结果：删除 S 的栈顶元素，并用 e 返回其值
 * @param S
 * @param e
 * @return
 */
Status Pop(SqStack *S, SElemType *e) {
    if (S->top == S->base) {  //栈为空
        return ERROR;
    }
    *e = *--S->top;
    return OK;
}

/**
 * 初始条件：栈 S 存在且非空
 * 操作结果：从栈底到栈顶依次对 S 的每个元素进行访问
 * @param S
 * @param vi
 */
Status StackTraverse(SqStack S, void(*vi)(SElemType)) {
    while (S.top > S.base) {  //遍历栈中元素
        vi(*S.base++);
    }
    printf("\n");
    return OK;
}

/**
 * 遍历函数
 * @param e
 */
void vi(SElemType e) {
    printf("%d ", e);
}

/**
 * 主函数，测试程序
 * @return
 */
int main() {
    SqStack s;
    SElemType e;

    InitStack(&s);
    printf("栈的长度：%d\n", StackLength(s));
    printf("栈是否为空：%d\n", StackEmpty(s));
    Push(&s, 3);
    Push(&s, 4);
    Push(&s, 5);
    Push(&s, 6);
    StackTraverse(s,vi);
    printf("栈的长度：%d\n", StackLength(s));
    printf("栈是否为空：%d\n", StackEmpty(s));
    GetTop(s, &e);
    printf("栈顶元素：%d\n", e);
    printf("栈的长度：%d\n", StackLength(s));
    Pop(&s, &e);
    StackTraverse(s, vi);
    ClearStack(&s);
    printf("栈的长度：%d\n", StackLength(s));
    printf("栈是否为空：%d\n", StackEmpty(s));

    DestroyStack(&s);
}

上面测试代码在 Clion 下的执行结果如下图所示。

链式栈

链栈是采用链式存储结构实现的栈。

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

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define INFEASIBLE 0

typedef int Status;
typedef int SElemType;

typedef struct StackNode {
    SElemType data;  //数据域
    struct StackNode *next;  //指针域
}StackNode, *LinkStack;

Status InitStack(LinkStack *S);
Status DestroyStack(LinkStack *S);
Status ClearStack(LinkStack *S);
Status StackEmpty(LinkStack S);
int StackLength(LinkStack S);
Status GetTop(LinkStack S, SElemType *e);
Status Push(LinkStack *S, SElemType e);
Status Pop(LinkStack *S, SElemType *e);
void StackTraverse(LinkStack S, void(*vi)(SElemType));

/**
 * 操作结果：构造一个空栈 S
 * @param L
 * @return
 */
Status InitStack(LinkStack *S) {
    S = NULL;  //构造一个空栈，栈顶指针置空
    return OK;
}

/**
 * 初始条件：栈 S 存在
 * 操作结果：栈 S 被销毁
 * @param S
 * @return
 */
Status DestroyStack(LinkStack *S) {
    LinkStack p;
    while (*S) {  //未到栈底
        p = (*S)->next;
        free(*S);  //释放栈顶空间
        *S = p;
    }
    return OK;
}

/**
 * 初始条件：栈 S 存在
 * 操作结果：将栈 S 清空
 * @param S
 */
Status ClearStack(LinkStack *S) {
    LinkStack q, p = (*S)->next;  // p 指向栈顶元素
    while (p) {  //未到栈底
        q = p->next;
        free(p);
        p = q;
    }
    (*S) = NULL;
    return OK;
}

/**
 * 初始条件：栈 S 存在
 * 操作结果：若 S 是空栈，返回 true，否则返回 false
 * @param S
 * @return
 */
Status StackEmpty(LinkStack S) {
    if (S == NULL) {
        return TRUE;
    } else {
        return FALSE;
    }
}

/**
 * 初始条件：栈 S 存在
 * 操作结果：返回栈 S 长度
 * @param S
 * @return
 */
int StackLength(LinkStack S) {
    int i = 0;  //计数器
    LinkStack p = S;  //p指向栈顶元素
    while (p) {  //未到栈底
        i++;
        p = p->next;
    }
    return i;
}

/**
 * 初始条件：栈 S 存在且非空
 * 操作结果；用 e 返回栈 S 的栈顶元素，不修改栈顶指针
 * @param S
 * @return
 */
Status GetTop(LinkStack S, SElemType *e) {
    if (S) {  //S 非空
        *e = S->data;
        return OK;
    }
    return ERROR;
}

/**
 * 初始条件：栈 S 存在
 * 操作结果：插入元素 e 为新的栈顶元素
 * @param L
 * @param e
 * @return
 */
Status Push(LinkStack *S, SElemType e) {
    LinkStack p;
    p = (LinkStack)malloc(sizeof(struct StackNode));  //生成新结点
    p->data = e;
    p->next = *S;  //将新结点插入栈顶
    *S = p;  //修改栈顶指针
    return OK;
}

/**
 * 初始条件：栈 S 存在且非空
 * 操作结果：删除栈顶元素，并用 e 返回且值
 * @param S
 * @param e
 * @return
 */
Status Pop(LinkStack *S, SElemType *e) {
    LinkStack p;
    if (!S) {
        return ERROR;
    }
    *e = (*S)->data;  //返回栈顶元素
    p = *S;  //p 临时保存栈顶空间，以备释放
    *S = (*S)->next;  //修改栈顶指针
    free(p);  //释放原栈栈顶空间
    return OK;
}

/**
 * 初始条件：栈 S 存在且非空
 * 操作结果：从栈底到栈顶依次对 S 中的每个元素进行访问
 * @param S
 * @param vi
 */
void StackTraverse(LinkStack S, void(*vi)(SElemType)) {
    LinkStack p = S;  //p 指向栈顶
    while (p) {
        vi(p->data);
        p = p->next;
    }
    printf("\n");
}

void vi(SElemType e) {
    printf("%d ", e);
}

/**
 * 主函数，测试程序
 * @return
 */
int main() {
    LinkStack s = NULL;
    SElemType e;

    InitStack(&s);
    printf("栈的长度：%d\n", StackLength(s));
    printf("栈是否为空：%d\n", StackEmpty(s));
    Push(&s, 3);
    Push(&s, 4);
    Push(&s, 5);
    Push(&s, 6);
    StackTraverse(s,vi);
    printf("栈的长度：%d\n", StackLength(s));
    printf("栈是否为空：%d\n", StackEmpty(s));
    GetTop(s, &e);
    printf("栈顶元素：%d\n", e);
    printf("栈的长度：%d\n", StackLength(s));
    Pop(&s, &e);
    StackTraverse(s, vi);
    ClearStack(&s);
    printf("栈的长度：%d\n", StackLength(s));
    printf("栈是否为空：%d\n", StackEmpty(s));

    DestroyStack(&s);
}

具体运行效果和顺序栈运行效果一样。

想要查看源码可以访问下面 github 链接，如果觉得不错，请给个 Star。

顺序栈
 链式栈

本文属数据结构系列持续更新中。

「数据结构四」C 语言实现栈

顺序栈

链式栈

猜你喜欢

热点阅读

「数据结构 四」C 语言实现栈

顺序栈

链式栈

猜你喜欢

热点阅读

「数据结构四」C 语言实现栈