《栈》

Posted 2020-11-05 xiangzhong-com

《栈》

目录：

1.栈的定义

2.栈的抽象数据类型

3.顺序栈

4.链栈

 

1.栈的定义

• 栈（Stack）是限定仅在表尾进行插入和删除的线性表。
• 我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom）。
• 不含任何数据元素的栈称为空栈。
• 栈为后进先出（Last In First Out）的线性表，简称LIFO结构。（如图1所示）

图1

• 栈的插入操作，叫做压入栈（push），或压栈。
• 栈的删除操作，叫做弹出栈（pop），或弹栈。

 

2.栈的抽象数据类型

类型名称：堆栈(Stack).

数据的对象集合：一个有0个或多个的元素的有求线性表。

操作集：对于一个具体的长度为正整数MaxSize的堆栈S属于Stack,记堆栈中的任意一个元素X属于ElementType,堆栈的基本操作主要有：

 

 

Stack CreateStack(int MaxSize);生成空堆栈，其最大长度为MaxSize。

bool IsFull(Stack S);判断堆栈S是否已满。

bool IsEmpty(Stack S); 判断堆栈S是否是空。

bool Push(Stack S,ElementType X);入栈。

ElementType Pop(Stack S);出栈。

 

3.顺序栈

一. 栈的顺序存储实现

#include<stdio.h>

#include<stdlib.h>

 

#define true 1

#define ERROR 0

#define false 0

 

typedef int bool;

typedef int ElementType;

typedef int Position;

typedef struct SNode* PtrToSNode;

typedef PtrToSNode Sequence_Stack;

 

struct SNode

{

    ElementType* Data;//存储元素的数组

    Position top;//栈顶指针

    int MaxSize;//顺序栈的最大容量

};

 

Sequence_Stack CreateStack(int MaxSize);

bool IsFull(Sequence_Stack S);

bool IsEmpty(Sequence_Stack S);

bool Push(Sequence_Stack S,ElementType X);

ElementType Pop(Sequence_Stack S);

 

int main()

{

    printf("请您输入您要输入多少数!\\n");

    int n = 0;

    int i = 0;

    scanf("%d", &n);

    Sequence_Stack S = CreateStack(n);

    int m = 0;

    while(i < n)

    {

        scanf("%d", &m);

        Push(S,m);

        i++;

    }

    i = 0;

    

    while(i < n)

    {

        printf("%d\\n", Pop(S));

        i++;

    }

    

    return 0;

}

 

Sequence_Stack CreateStack(int MaxSize)

{

    Sequence_Stack S = (Sequence_Stack)malloc(sizeof(struct SNode));

    S->Data = (ElementType*)malloc(MaxSize*sizeof(ElementType));

    S->top = -1;

    S->MaxSize = MaxSize;

    return S;

}

 

bool IsEmpty(Sequence_Stack S)

{

    if(S->top == -1)

    {

        return true;

    }

    else

    {

        return false;

    }

}

 

bool IsFull(Sequence_Stack S)

{

    if(S->top == S->MaxSize-1)

    {

        return true;

    }

    else

    {

        return false;

    }    

}

 

bool Push(Sequence_Stack S, ElementType X)

{

    if(IsFull(S))

    {

        printf("顺序栈满!\\n");

        return false;

    }

    else

    {

        S->top++;

        S->Data[S->top] = X;

        //简洁版：S->Data[++(S->top)] = X;

        return true;

    }

}

 

ElementType Pop(Sequence_Stack S)

{

    if(IsEmpty(S))

    {

        printf("顺序栈空!\\n");

        return false;

    }

    else

    {

        S->top--;

        return S->Data[S->top+1];

        //简洁版：return S->Data[(S->top)--];

    }

}

 

二. 栈的共享顺序存储实现

通常，当两个栈的空间需求有相反关系时，也就是一个栈增长时另一个栈在缩短的情况下，可以使用两栈共享空间。

 

#include<stdio.h>

#include<stdlib.h>

 

#define true 1

#define ERROR 0

#define false 0

 

typedef int bool;

typedef int ElementType;

typedef int Position;

typedef struct SNode* PtrToSNode;

typedef PtrToSNode Sequence_Share_Stack;

 

struct SNode

{

    ElementType* Data;//存储元素的数组

    Position top1;//堆栈1的栈顶指针

    Position top2;//堆栈2的栈顶指针

    int MaxSize;//顺序栈的最大容量

};

 

Sequence_Share_Stack CreateStack(int MaxSize);

bool Push(Sequence_Share_Stack S, ElementType X, int Tag);

ElementType Pop(Sequence_Share_Stack S, int Tag);

 

int main()

{

    //请读者根据自己的需求来完善代码，这里已经把共享栈搭建好了!

    return 0;

}

 

Sequence_Share_Stack CreateStack(int MaxSize)

{

    Sequence_Share_Stack S = (Sequence_Share_Stack)malloc(sizeof(struct SNode));

    S->Data = (ElementType*)malloc(MaxSize*sizeof(ElementType));

    S->top1 = -1;

    S->top2 = S->MaxSize;

    S->MaxSize = MaxSize;

    return S;

}

 

bool Push(Sequence_Share_Stack S, ElementType X, int Tag)

{

    if(S->top2 - S->top1 == 1)

    {

        printf("共享栈满!\\n");

        return false;

    }

    else

    {

        if(Tag == 1)

        {

            S->Data[++(S->top1)] = X;     

        }

        else

        {

            S->Data[--(S->top2)] = X;

        }

        return true;

    }

}

 

ElementType Pop(Sequence_Share_Stack S, int Tag)

{

    if(Tag == 1)

    {

        if(S->top1 == -1)

        {

            printf("栈1空\\n");

        }

        else

        {

            return S->Data[(S->top1)--];

        }

    }

    else

    {

        if(S->top2 == S->MaxSize)

        {

            printf("栈2空\\n");

            

        }

        else

        {

            return S->Data[(S->top2)++];

        }

        

        

    }

}

 

4.链栈

栈的链式存储实现

//链栈基本结构已搭建好了，用斐波那契函数来完善了链栈的实现

#include<stdio.h>

#include<stdlib.h>

 

#define OK 1

#define ERROR 0

 

typedef int bool;

typedef int SElemType;

 

typedef struct StackNode

{

SElemType data;

struct StackNode *next;

}StackNode,*LinkStackPtr;

 

typedef struct

{

LinkStackPtr top; /*栈顶指针*/

int count; /* 链栈元素个数*/

}LinkStack;

 

LinkStack* InitStack();

bool Push(LinkStack *S,SElemType e);

bool Pop(LinkStack *S,SElemType *e);

int Fbi(int i);

void Fbistore();

 

int main()

{

    Fbistore();

 

 

return 0;

}

 

LinkStack* InitStack()

{

LinkStack* s = (LinkStack*)malloc(sizeof(LinkStack));

if(!s)

{

printf("内存分配失败！\\n");

return NULL;

}

memset(s, 0x00, sizeof(LinkStack));

 

return s;

}

//进栈

bool Push(LinkStack *S,SElemType e)

{

LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode));

s->data=e;

s->next=S->top;    /* 把当前的栈顶元素赋值给新结点的直接后继，见图中① */

S->top=s; /* 将新的结点s赋值给栈顶指针，见图中② */

S->count++;

return OK;

}

 

//出栈

bool Pop(LinkStack *S,SElemType *e)

{

LinkStackPtr p;

if(S->count == NULL)

return ERROR;

*e=S->top->data;

p=S->top;                    /* 将栈顶结点赋值给p，见图中③ */

S->top=S->top->next; /* 使得栈顶指针下移一位，指向后一结点，见图中④ */

free(p); /* 释放结点p */

S->count--;

return OK;

}

 

 

 

int Fbi(int i) /* 斐波那契的递归函数 */

{

    if( i < 2 )

        return i == 0 ? 0 : 1;

/* 这里Fbi就是函数自己，等于在调用自己 */

return Fbi(i - 1) + Fbi(i - 2);

}

 

 

 

 

void Fbistore()

{

//初始化一个空栈

LinkStack* s = InitStack();

int a = 0;

    int m = 0, i = 0;

    scanf("%d", &m);

while(i <= m)

{

Push(s, Fbi(i));

        i++;

 

}

while(s->count != 0)

{

Pop(s, &a);

printf("%d ", a);

}

    printf("\\n");

}

 

接下来将发布栈的几个具体应用（表达式求值 迷宫问题）