序言

複習棧的基本操作及其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;
}

2017.08.29