数据结构-栈ADT

栈（stack）是限定仅在表尾插入和删除操作的线性表

允许插入和删除的一端称为栈顶(top)，另一端称为栈底（bottom）

 我们可以类比手枪弹夹，浏览器的后退和前进等等都是栈

栈的插入操作，称为进栈，也称压栈、入栈（push）
栈的删除操作，称为出栈，也称为弹栈（pop）

栈本身就是一个线性表，线性表的顺序存储和链式存储，对于栈来说也同样适用 

 

堆栈的顺序表示（利用数组）

typedef struct
{
	int top; //当前栈顶位置下标
	int maxsize; //栈堆最大位置下标
	ELemType *element; // ELemType可以定义为int float 等数据类型 element指向一维数组
}Stack;

/****
*堆栈的顺序表示
****/

//创建
void Creat(Stack * S,int * mSize)
{
	S->maxSize = mSize - 1;
	S->element = (ElemType*)malloc(sizeof(ElemType)*mSize);
	S->top = -1;
}

//销毁
void Destroy(Stack *S)
{
	S->maxSize = -1;
	free(S->element);
	S->top = -1;
}

//判断是否为空栈
BOOL IsEmpty(Stack *S)
{
	return S->top==-1;
}

//判断栈是否已满
BOOL IsFull(Stack *S)
{
	return S->top==S->maxSize;
}

//获取栈顶元素
BOOL Top(Stack *S , ElemType *x)
{
	if(IsEmpty(S))
		return FALSE;
	x = S->element[S->top];
	return TRUE;
}

//在栈顶插入元素
BOOL Push(Stack *S,ElemType x)
{
	if(IsFull(S))
		return FALSE;
	S->top++;
	S->element[S->top]=x;
	return TRUE;
}

//删除栈顶的元素
BOOL Pop(Stack *S)
{
	if(IsEmpty(S))
		return FALSE;
	S->top--;
	return TRUE;
}

//清除栈中的元素，但不释放内存
void Clear(Stack *S)
{
	S->top=-1
}

堆栈的链接表示（利用单链表）

 

入栈示意图 

出栈示意图 

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

typedef struct StackNode{
	int element; //这里的数据结构我将它具体化为 int （上面的使用的是抽象数据类型）
    struct StackNode * next;
} StackNode;

typedef struct LinkStack{
    struct StackNode * top;//栈顶指针 用于寻找栈
	int length;//栈的长度
} LinkStack;

//初始化
int init(LinkStack * linkstack)
{
	linkstack->top = (StackNode * )malloc(sizeof(StackNode)); 
	linkstack->length = 0;
	return 1;
}

//入栈
int push(LinkStack * linkstack ,int data)
{
    StackNode * newnode = (StackNode * )malloc(sizeof(StackNode));
	newnode->element = data;
	//新节点next指向栈顶 头插法
	newnode->next = linkstack->top;
	linkstack->top = newnode;
	linkstack->length++;
	return 1;
}

//出栈
int pop(LinkStack * linkstack,int * data)
{
	if(linkstack->top == NULL)
	{
		printf("空栈 出栈失败");
		return 0;
	}
    *data = linkstack->top->element;
	StackNode * node = linkstack->top;
	//栈顶指针下移一位
	linkstack->top = linkstack->top->next;
	free(node);
	linkstack->length--;
	return 1;
}

//栈元素清空
void clear(LinkStack * linkstack)
{
	StackNode * tempnode;
	while(linkstack->top)
	{
         tempnode = linkstack->top;
		 linkstack->top = linkstack->top->next;
		 free(tempnode);
		 linkstack->length--;
	}
}

//销毁
void destroy(LinkStack * linkstack)
{
	clear(linkstack);
	free(linkstack);
	linkstack = NULL;
}

最后利用栈我们可以完成类似于悔棋的一个小的demo

/*此模型利用顺序栈实现简单的五子棋悔棋模型
  在cpp中只需要将data_t数据类型改为类（结构体）储存位置
  可利用模板实现
  同样栈也可以利用链表实现
*/

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 20

#define OK 1

#define ERROR 0



typedef int data_t;

typedef struct

{

data_t data[MAXSIZE];

int top;

}SqStack;



int PushStack(SqStack *s,data_t e)//压栈

{

if(s->top==MAXSIZE-1)

{

printf("Stack is Full\n");

return ERROR;

}

s->top++;

s->data[s->top]=e;

return OK;

}



int PopStack(SqStack *s,data_t *e)//弹栈

{

if(s->top==-1)

{

printf("Stack is Empty\n");

return ERROR;

}

*e=s->data[s->top];

s->top--;

return OK;

}

SqStack* CreateEmptyStack()//创建栈

{

SqStack *stack = (SqStack*)malloc(sizeof(SqStack));

if(stack==NULL)

{

printf("CreateEmptyStack Error\n");

exit(0);

}

stack->top=-1;

return stack;

}

int EmptyStack(SqStack *s)//判断栈是否是空栈

{

return -1==s->top?OK:ERROR;

}

int FullStack(SqStack *s)//判断栈是否是满栈

{

return MAXSIZE-1==s->top?OK:ERROR;

}

int ClearStack(SqStack *s)//清空栈内元素

{

s->top=-1;

return OK;

}

int main()

{

SqStack *stack = CreateEmptyStack();

data_t data;

PushStack(stack,1); //B

PushStack(stack,2); //W

PushStack(stack,3); //B

PushStack(stack,4); //W

for(int i = 0 ; i < 4 ; i++)

printf("悔棋前数组的元素:%d\n",stack->data[i]);

PopStack(stack,&data); //悔棋一步

printf("pop:%d\n",data); //将栈顶元素弹出

for(i = 0 ; i < 3 ; i++)

printf("悔棋后数组的元素:%d\n",stack->data[i]);

return 0;

}