算法与数据结构-栈的基本操作C语言实现

序言

复习栈的基本操作及其C语言实现，主要以链式栈为例。

本文将介绍栈的以下基本操作：

• 栈的建立（顺序栈和链式栈）

• 栈的初始化

• 栈遍历

• 栈清空/销毁

• 判断栈是否为空

• 求栈的长度

• 返回并删除栈顶元素

1. 栈建立 - 顺序栈和链式栈

//顺序栈的存储结构定义如下
typedef int ElemType;
#define MAXSIZE 100

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


//链式栈的存储结构定义如下
typedef struct stack_node         //节点存储结构体
{
    ElemType data;
    struct stack_node *next;
}SNode, *stackNode;

typedef struct link_list_stack    //栈结构
{
    SNode *top;      //栈顶指针
    SNode *bottom;   //栈底指针（如果需要的话）
    int size;        //元素个数计数
}LinkStack;

2. 链式栈的基本操作

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

//链式栈定义
typedef int ElemType;
typedef struct stack_node
{
    ElemType data;
    struct stack_node *next;
}SNode, *stackNode;

typedef struct link_list_stack
{
    SNode *top;
    SNode *bottom;  //if needed
    int count;      //element counter if needed
}LinkStack;

//链式栈初始化
void StackInit(LinkStack *stack)
{
    if ((stack->top = (SNode *)malloc(sizeof(SNode))) == NULL)
    {
        printf("动态内存分配失败!\n");
        exit(-1);
    }
    stack->bottom = stack->top;
    stack->top->next = NULL;
    stack->count = 0;
}

//判断栈是否为空
int IsEmpty(LinkStack *stack)
{
    if (stack->top == stack->bottom)    //或者按stack->count来判断
        return 1;
    return 0;
}


//元素入栈
void Push(LinkStack *stack, int elem)
{
    //申请空间
    SNode *newNode = (SNode *)malloc(sizeof(SNode));
    newNode->data = elem;

    //Push到栈中
    newNode->next = stack->top;        //先。
    stack->top = newNode;              //后。将栈节点“串起来”
    stack->count++;
}

//出栈，元素存储在value指针中
void Pop(LinkStack *stack, int *value)
{
    if (IsEmpty(stack))
    {
        printf("stack is empty\n");
        return;
    }
    //提取节点
    SNode *tempNode = (SNode *)malloc(sizeof(SNode));
    tempNode = stack->top;
    *value = tempNode->data;

    //栈指针变动
    stack->top = tempNode->next;
    stack->count--;

    //释放栈节点
    free(tempNode);       //说明：当插入新元素时，栈顶指针得到更新，指向新的节点
    tempNode = NULL;
}

//栈遍历
void StackTraverse(LinkStack *stack)
{
    //节点扫描
    SNode *nodeScan = stack->top;

    //遍历输出
    while (nodeScan != stack->bottom)
    {
        printf("%d ", nodeScan->data);
        nodeScan = nodeScan ->next;         //元素入栈过程中，已将节点依次“串起来”，所以可以反向操作
    }
    printf("\n");
    return;
}

//求栈的长度
int StackLength(LinkStack *stack)
{
    return stack->count;
}


//清空/销毁栈
void EmptyStack(LinkStack *stack)
{
    if (IsEmpty(stack))
        return;
    SNode *nodeScan = stack->top;
    SNode *tempNode = (SNode *)malloc(sizeof(SNode));
    tempNode = NULL;
    while (nodeScan != stack->bottom)       //或count != 0
    {
        tempNode = nodeScan->next;
        free(nodeScan);
        nodeScan = tempNode;
        stack->count--;
    }
    stack->top = stack->bottom;
}

int main()
{
    //链式栈建立及初始化
    LinkStack *stack = (LinkStack *)malloc(sizeof(LinkStack));      //记得为链式栈分配空间
    StackInit(stack);
    int i = 0;
    for (; i < 10; i++)     //往栈中压入10个元素
    {
        Push(stack, i + 1);
    }
    //判断栈是否为空
    IsEmpty(stack);
    //栈遍历
    StackTraverse(stack);
    //取出并删除栈顶元素
    int value;
    Pop(stack, &value);
    //清空/销毁栈
    EmptyStack(stack);
    return 0;
}

3. 顺序栈的基本操作

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

typedef int ElemType;
typedef struct sequence_stack
{
    ElemType array[MAXSIZE];
    int top;
}seqStack;

//建立空栈
seqStack *Create()
{
    seqStack *stk = (seqStack *)malloc(sizeof(seqStack));
    stk->top = -1;
    return stk;
}

//入栈操作
void Push(seqStack *stack, int elem)
{
    stack->top++;
    stack->array[stack->top] = elem;
}

//出栈操作
void Pop(seqStack *stack, int *elem)
{
    *elem = stack->array[stack->top];
    stack->top--;
}

//销毁栈
void Destroy(seqStack *stack)
{
    free(stack);
}

//主函数
int main()
{
    seqStack *stack;
    stack = Create();       //创建
    int elem_in = 11;
    int elem_out;
    //入栈
    Push(stack, elem_in);
    //出栈
    Pop(stack, &elem_out);
    //循环出栈/遍历
    int temp;
    while (stack->top >= 0)
    {
        printf("%d\n", stack->array[stack->top]);
        Pop(stack, &temp);          //元素出栈后top--
    }
    Destroy(stack);
    return 0;
}

注：顺序栈的其他基本操作可参考：http://www.cnblogs.com/jingliming/p/4602458.html

Acknowledgements:
http://blog.csdn.net/scu_daiwei/article/details/8537139
http://blog.csdn.net/willinux20130812/article/details/46124841
http://www.cnblogs.com/liangyan19910818/archive/2011/09/10/2172945.html

2017.08.29