数据结构-顺序栈

一.顺序栈的定义  

1.定义

在了解顺序站之前先了解什么是栈：

 栈的概念：

1、栈：一种只允许在一端进行插入或删除的线性表

2、栈顶：线性表允许进行插入删除的那一端

3、栈底：固定的，不允许进行插入和删除的那一端

4、空栈：不含任何元素的空表

栈了解完了我们在了解顺序栈

顺序栈的定义

   顺序栈是栈的顺序实现。顺序栈是指利用顺序存储结构实现的栈。采用地址连续的存储空间（数组)依次存储栈中数据元素，由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处；栈顶位置是随入栈和出栈操作而变化的，故需用一个整型变量top来记录当前栈顶元素在数组中的位置。

  2.特点

 修改顺序是按照先进后出的原则进行，因此又被称为先进后出的顺序表

二.顺序栈的代码讲解

 1.栈的使用

   1.初始化

     创建一个空的顺序栈

​
/*
	seqstack.h
	顺序栈
*/

typedef int DataType;


typedef struct
{
	DataType *data; /* 堆空间 */
	int maxsize;
	int top;		/* 栈顶指针 */
}SeqStack;


/* 1. 初始化 */
int init(SeqStack *S, int MaxSize);

   2.进栈

     完成之前的“先进”，将元素放进栈中，进去步骤

        1.首先判断栈是否已满（栈满条件为top=MaxSize）；

        2.若栈未满，则移动指针将入栈的元素放入数组中top的top+1的位置。

/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}

	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}

   3.出栈

    最先进去的最后面出来；类似那羽毛球最先放进去的最后面拿出来；

        1.首先判断栈是否已满（栈满条件为top=MaxSize）；

        2.若栈未满，则移动指针将入栈的元素放入数组中top的top+1的位置。

/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}

	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}

   4.取栈顶

   顾名思义 拿栈最顶上面的那个元素，

   1.判断栈是否为空

   2.不为空则取出最为顶部的元素

int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}

	*x = S->data[S->top];	/*栈顶元素赋值给x*/

	return 0;
}

   5.是否为空

判断顺序栈是否为空，即栈顶指针top是否为-1。若top为-1，则栈为空。

int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}

   6.是否为满

判断顺序栈是否为满，即栈顶指针top是否为-1。若top为-1，则栈为空。

/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}

   7.销毁栈

释放顺序栈所占用的内存空间

int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

 2.栈的应用

  1.十进制改为二进制

    进制整数转换为二进制整具体算法是：用2去除十进制整数，得到一个商和余数，再用2去除商，得到一个商和余数，如此进行，直到商为零时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位依次排列起来。

	if(cmd == 1)
				{
					printf("请输入一个十进制数：");
					scanf("%d", &d);
					printf("二进制为：");
					d_to_b(d);
					printf("\n");
				}

				if(cmd == 2)
				{
					expression();
				}
			}while(cmd!=0);
			cmd = -1;
			break;
		}

	}while(cmd!=0);

它利用了顺序栈 将函数 d_to_b 一个十进制整数 d 转换为二进制表示的方法，这个函数就是利用栈的性质（后进先出）和除2取余的方法，将一个十进制数转换为一个二进制数。

步骤如下

   1.这个函数创建了一个顺序栈 S，并初始化它的大小为32。

    2.在while循环中，只要 d 不为0，就会一直执行循环。在每次循环中，都会计算 d 对2的余数，并将这个余数推入栈中。然后，将 d 除以2，向下取整，这样就可以在下一次迭代中得到 d 对2的新余数。

  3.在一个类似的while循环中，只要栈不为空，就会持续执行循环。在每次循环中，都会从栈中弹出一个元素，并将其值存储在 b 中。然后，将这个值打印出来。

   4.最后，使用 destroy 函数销毁栈 S，释放其占用的内存。  2.后缀运算

2.后缀计算法

在讲解代码前先来了解后缀表达式

后缀表达式是一种数学表示方法；将计算符号与符号后面的数字（式子）进行调换，

列如 3+5 ——>3 5 +

在从计算机语言的角度来说首先创建了一个顺序栈，用于临时存储操作数和运算结果。然后，它从用户输入的后缀表达式中逐个读取字符，对于每个字符进行不同的操作：

        1.字符是数字（'0'~'9'），则将其转换为对应的整数值，并将其压入栈中。

        2.字符是运算符（+，-，*，/），则从栈中弹出两个操作数，进行加法运算，并将结果压入栈中。

最后遍历完整个后缀表达式后，栈中最后剩下的元素就是计算结果。

/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int x;

	char exp[20]; /*后缀表达式*/

	init(&S, 10);

	printf("请输入一个后缀表达式(eg. 56+):");
	scanf("%s", exp);

三.顺序栈完整代

main.c

#include <stdio.h>
#include <string.h>

#include "seqstack.h"

/*十进制转换为二进制*/
int d_to_b(int d);

/*后缀表达式计算*/
int expression();

int main(int argc, char* argv[])
{
	SeqStack S;

	int cmd;
	int d;

	DataType x;
	int maxsize;
	char yn;

	
	do
	{
		printf("---------顺序栈演示程序-----------\n");
		printf(" 1. 初始化\n");
		printf(" 2. 入栈\n");
		printf(" 3. 出栈\n");
		printf(" 4. 取栈顶元素\n");
		printf(" 5. 栈是否空？\n");
		printf(" 6. 栈是否满？\n");
		printf(" 7. 销毁栈\n");
		printf(" 8. 栈的应用\n");
		printf("请选择（0~9,0退出)：");
		scanf("%d", &cmd);
		switch(cmd)
		{
		case 1:
			printf("请输入栈的最大存储空间(MaxSize)：");
			scanf("%d", &maxsize);
			if(!init(&S, maxsize))
			{
				printf("栈已初始化！\n");
			}
			break;
		case 2:
			printf("请输入入栈元素：x=");
			scanf("%d", &x);
			if(!push(&S, x))
			{
				printf("元素【%d】已入栈！\n", x);

			}
			break;
		case 3:
			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
			flushall();
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!pop(&S, &x))
				{
					printf("栈顶元素【%d】已出栈！\n", x);
				}
			}

			break;

		case 4:
			  printf("取出栈顶：【%d】\n",x);
   			  break;

		case 5:
			if(empty(&S)){
			  printf("为空\n");
			}
			else{
			   printf("不为空\n");
			}
			break;

		case 6:
			if(full(&S)){
			  printf("满\n");
			}
			else{
			 printf("未满\n");
			}
       break;
		case 7:
            destroy(&S);
		    printf("已销毁");
			break;

		case 8:
			do
			{
				printf("----------8.栈的应用------------\n");
				printf(" 1. 十进制转换为二进制\n");
				printf(" 2. 后缀表达式计算\n");			
				printf(" 0. 返回\n");
				printf("请选择：");
				scanf("%d", &cmd);

				if(cmd == 1)
				{
					printf("请输入一个十进制数：");
					scanf("%d", &d);
					printf("二进制为：");
					d_to_b(d);
					printf("\n");
				}

				if(cmd == 2)
				{
					expression();
				}
			}while(cmd!=0);
			cmd = -1;
			break;
		}

	}while(cmd!=0);

	return 0;
}


/*十进制转换为二进制*/
int d_to_b(int d)
{
	SeqStack S;
	int b;

	/*初始化栈*/
	init(&S,32);

	/*d不为0，余数进栈*/
	while(d)
	{
		push(&S, d % 2);
		d /= 2;
	}
	
	/*依次出栈*/
	while(!empty(&S))
	{
		pop(&S,&b);
		printf("%d", b);
	}

	/*销毁栈*/
	destroy(&S);
}


/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int x;

	char exp[20]; /*后缀表达式*/

	init(&S, 10);

	printf("请输入一个后缀表达式(eg. 56+):");
	scanf("%s", exp);

	for(i=0;i<strlen(exp);i++)
	{
		switch(exp[i])
		{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			/*入栈*/
			push(&S, exp[i]-48);
			break;
		case '+':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 + op2;
			push(&S, x);
			break;

		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			push(&S, x);
			break;

        case '-':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 - op2;
			push(&S, x);
			break;

		case '/':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 / op2;
			push(&S, x);
			break;
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

 seqstack.c

/*
	seqstack.c
*/
#include <stdio.h>
#include <malloc.h>
#include "seqstack.h"


/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
	/*申请内存空间*/
	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);

	if(!S->data)
	{
		printf("内存申请错误，初始化失败！[10001]\n");
		return 10001;
	}
	S->maxsize = MaxSize;
	S->top = -1;
	return 0;
}


/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}

	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}

/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}

	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	

	return 0;
}

/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}

	*x = S->data[S->top];	/*栈顶元素赋值给x*/

	return 0;
}

/* 5. 栈为空？*/
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}

/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}


/* 7. 销毁*/
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

四.顺序栈的运算结果

这里包括所有的结果

五.本章小结

关于这次总结

1.有关顺序栈

（1）明白顺序的定义以及特点

（2）如何的去使用顺序栈以及有关他的一些关键字的使用以及如何去实现栈的一些操作

2.有关栈的应用操作（包括十进制改为二进制以及后缀计算法）

（1）十进制改为二进制：首先在算数方面要了解它，其次在计算机方面如想着使用int d_to_b函数更好的应用

（2）后缀计算法;在后缀计算如同十进制改为二进制先要了解算数方面的理解，其次才是计算机方面的expression()的实行