数据结构:《栈》

《栈》

目录：

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");
}

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