数据结构之栈的实现

根据栈的存储结构可以分为顺序栈和链栈

参考：

顺序栈的讲解-CSDN博客

顺序栈

顺序栈的定义
复制代码
typedef struct//堆栈结构体定义
{
	int top;//栈顶指针
	int data[MaxSize];//静态数组存放栈中元素
}SqStack;
顺序栈的初始化

初始化只需把栈顶指针指向-1就可以了。
复制代码
void InitStack(SqStack &S)//初始化栈
{
	S.top = -1;//初始化栈顶指针
}
顺序栈的出栈

1.判断是否为空栈，空栈无法进行出栈操作。

2.先赋值给x再移动栈顶指针，并且是向下移动。
复制代码
bool Printf(SqStack &S,int &x)//出栈(删除栈顶元素)
{
		if (S.top == -1)//判断是否为空栈
			return false;
		x = S.data[S.top];//让x等于此时栈顶指针所指的元素
		S.top = S.top - 1;//栈顶指针往下移动一位
	return true;
}
顺序栈的入栈

1.判断是否为栈满，栈满无法进行入栈操作。

2.栈顶指针先向上移动，再把输入的数据放进去。
复制代码
bool Push(SqStack &S)//入栈（在栈顶位置插入元素）
{
	printf("请输入%d个数:", MaxSize);
	for (int i = 0; i < MaxSize; i++)
	{
		if (S.top == MaxSize - 1)//判断栈满了没有
			return false;
		S.top = S.top + 1;//栈顶指针往上移动一位
		scanf("%d", &S.data[S.top]);//把这次输入的元素放入此时栈顶指针指向的位置
	}
		return true;
}
判断栈空

只需要判断栈顶指针指向的是不是-1，因为一开始空栈的时候栈顶指针指向的是-1。
复制代码
int testStack(SqStack &S)//判断栈空
{
	return (S.top == -1);//空栈返回1，反之返回0。
}
判断栈满

由于栈顶指针指向的是-1，所以一开始放入的位置是0，栈满的时候就会是MaxSize-1，只需判断栈顶指针指向的是不是MaxSize-1就好了。
复制代码
int IsFull(SqStack &S)//判断栈满
{
	return (S.top == MaxSize-1);//满栈返回1，反之返回0。
}
读取栈顶元素

取栈顶元素的操作和一次出栈类似，但是不需要进行栈顶指针的移动。
复制代码
bool GetTop(SqStack &S)//读取栈顶元素，操作和出栈类似，top不需要减1。
{
	if (S.top == -1)//判断空栈
		return false;
	int x = S.data[S.top];
	printf("栈顶元素是：%d\n", x);
	return true;
}
取有效元素个数

栈顶指针+1就可以了。
复制代码
int lenth(SqStack &S)//求有效元素的个数
{
	return S.top + 1;
}
遍历

遍历是进行多次的出栈操作，并把每次出栈的数据打印出来。给出栈操作加上循环和输出即可。

暂略。
其实顺序栈就是个操作受限的顺序表。

链栈

参考：链栈及其基本操作-CSDN博客
链栈定义

复制代码

typedef int elemtype;  //数据域数据类型
 
typedef struct LinkedStackNode
{
	elemtype data;
	LinkedStackNode *next;
}LinkedStackNode,*LinkedStack;

初始化

复制代码

LinkedStack Init_LinkedStack()
{
	LinkedStack top = (LinkedStackNode *)malloc(sizeof(LinkedStackNode));  
	                              //栈顶指针变量
	if(top != NULL)
	{
		top->next = NULL;
	}
	return top;
}

判断是否为空

复制代码

int LinkedStack_Empty(LinkedStack top)
{
	if(top->next == NULL)//如果栈顶的指针域指向空，则栈空
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

入栈

复制代码

int Push_LinkedStack(LinkedStack top,elemtype x)
{
	LinkedStackNode * node = (LinkedStackNode *)malloc(sizeof(LinkedStackNode));
 
	if(node == NULL)
	{
		return 0;
	}
	else
	{
		node->data = x;
		node->next = top->next;
		top->next = node;
		return 1;
	}
}

出栈

复制代码

int Pop_LinkedStack(LinkedStack top,elemtype *x)
{
	LinkedStackNode *node;
	if(top->next == NULL)
	{
		return 0;
	}
	else
	{
		node = top->next;
		*x = node->data;
		top->next = node->next;
		free(node);
		return 1;
	}
}

读取栈顶元素

复制代码

int Get_LinkedStack(LinkedStack top,elemtype *x)
{
	if(top->next == NULL)
	{
		return 0;
	}
	else
	{
		*x = top->next->data;
		return 1;
	}
}

其实链栈就是个操作受限的单链表