大话数据结构7栈和队列1

1、栈

  定义：限定仅在表尾进行插入和删除操作的线性表

      允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)，不含任何数据元素的栈称为空栈。栈又称为后进先出(Last In Fisrt Out)的线性表，简称LIFO结构

      首先是一个线性表，栈元素具有线性关系，即前驱后继关系。栈的插入操作，叫作进栈，也称为压栈、入栈，栈的删除操作，称作出栈，弹栈。

  进栈出栈变化形式：

例：1、2、3依次进栈，会有哪些出栈的次序？

  答：321、213、123、132、231

  栈的抽象数据类型：

		ADT 栈(stack)
		Data  同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系
		Operation
			InitStack(*S):初始化操作，建立一个空栈S
			DestroyStack(*S）:若栈存在，则销毁它
			ClearStack(*S):将栈清空
			StackEmpty(*S):若栈为空，返回true，否则返回false
			GetTop(S,*e):若栈存在且非空，用e返回S的栈顶元素
			Push(*S,*e):若栈S存在，输入新元素e到栈S中并成为栈顶元素(push压)
			Pop(*S，*e):删除栈S中栈顶元素，并用e返回其值(pop弹)
			StackLength(s):返回栈S的元素个数
		endADT

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

  栈的顺序存储结构及实现

栈的顺序存储结构：栈的顺序存储简称顺序栈，用数组来实现的，下标为0的一端作为栈底，定义一个top变量来指示栈顶位置在数组中位置。当空栈的判定条件为top等于-1.

		typedef int SElemType; /*SElemType类型根据实际情况而定，这里假设为int*/
		typedef struct
		{
			SElemType data[MAXSIZE];
			int top;        /*用于栈顶指针*/
		}SqStack;

  进栈操作：

		/*插入元素e为新的栈顶元素*/
		Status Push(SqStack *S,SElemType e)
		{
			if(S->top == MAXSIZE - 1)      /*栈满*/
			{
				return ERROR;
			}
			S->top++;                 /*栈顶指针增加1*/
			S->data[S->top] = e;          /*将新插入元素赋值给栈顶空间*/
			return OK;
		}

  出栈操作：

		/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK，否则返回ERROR*/
		Status Pop(SqStack *s,SElemType *e)
		{
			if(S->top == -1)
			{
				return ERROR;
			}
			*e = S->data[S->top];   /*将要删除的栈顶元素赋值给e*/
			S->top--;           /*栈顶指针减1*/
			return OK;
		}

两栈共享空间：

		       /*两栈共享空间结构*/
		typedef struct	
						{
			SElemType data[MAXSIZE];
			int top1;
			int top2;
		}SqDoubleStack;

  插入元素的代码：

		        /*插入元素e为新的栈顶元素*/
		Status Push(SqDouleStack *s,SElemType e,int stackNumber)
		{
			if(S->top1 + 1 == S->top2)   /*栈已满，不能再push新元素了*/
				return ERROR;
			if(stackNumber == 1)       /*栈1有元素进栈*/
				S->data[++S->top1] = e;  /*若栈1则先top1+1后给数组元素赋值*/
			else if(stackNumber == 2)      /*栈2有元素进栈*/
				S->data[--S-.top2] = e;  /*若栈2则先top2-1后给数组元素赋值*/
			return OK;
		}

  两栈共享空间的pop代码：

		/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK;否则返回ERROR*/
		Status Pop(SqDouleStack *S,SElemType *e,int stackNumber)
		{
			if(stackNumber == 1)
			{
				if(S->top1 == -1)
					return ERROR;   /*说明栈1已经是空栈，退出*/
				*e = S->data[S->top1 == 1]; /*将栈1的栈顶元素出栈*/
			}
			else if(StackNumber == 2)
			{
				if(S->top2 == MAXSIZE)
					return ERROR;     /*说明栈2已经是空栈，溢出*/
				*e = S->data[S->top2++];   /*将栈2的栈顶元素出栈*/
			}
			return OK;
		}

注意：只是针对两个相同数据类型的栈

  栈的链式存储结构及实现：

对于空栈来说，链栈的空是top == NULL

链栈的结构代码：

		typedef struct StackNode
		{
			SElemType data;
			struct StackNode *next;
		}StackNode,*LinkStackPtr;

		typedef struct LinkStack
		{
			LinkStackPtr top;
			int count;
		}LinkStack;

  进栈操作：

		/*插入元素e为新的栈顶元素*/
		Status Push(LinkStack *S,SElemType e)
		{
			LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
			s->data = e;
			s->next = S->top;  /*把当前的栈顶元素赋值给新结点的直接后继*/
			S->top = s;      /*将新的结点赋值给栈顶指针*/
			S->count++;
			return OK;
		}

  出栈操作：

		        /*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
		Status Pop(LinkStack *S,SElemType *e)
		{
			LinkStackPtr p;
			if(StackEmpty(*S))
			{
				return ERROR;
			}
			*e = S->top->data;
			p = S->top；   /*将栈顶结点赋值给p*/
			s->top = S->top->next;  /*使得栈顶指针下移一维，指向后一个结点*/
			free(p);            /*释放结点p*/
			S->count--;
			return OK;
		}

  链栈的进栈和出栈的时间复杂度均为O(1)。

  链栈要求每一个元素都有指针域，增加了内存开销

  栈的作用：简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于问题核心

  栈的应用——递归：

1、菲波那切数列

打印前40位的斐波那契数列数

				int main()
				{
					int i;
					int a[40];
					a[0] = 0;
					a[1] = 1;
					printf("%d",a[0]);
					printf("%d",a[1]);
					for(i = 2;i < 40;i++)
					{
						a[i] = a[i - 1] + a[1 - 2];
						printf("%d",a[i]);
					}
					return 0;
				}

		/*斐波那契的递归函数*/
		int Fbi(int i)
		{
			if(i < 2)
			{
				return i == 0 ? 0 : 1;
			}
			return Fbi(i - 1) + Fbi(i - 2）；  /*这里的Fbi就是函数自己，在调用自己*/
		}
		int main()
		{
			int i;
			for(int i = 0;i < 40;i++)
			{
				printf("%d",Fbi(i));
			}
			return 0;
		}

  递归定义：把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称作递归函数，必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回退出

  迭代和递归的区别：迭代使用的是循环结构，递归使用的是选择结构；迭代不需要反复调用函数和占用额外的内存，递归能使程序的结构更清晰，更简洁，更容易让人理解，从而减少读懂代码的时间，但是大量的递归调用会建立函数的副本，会耗费大量的时间和内存。

  在前行阶段，对于每一层递归，函数的局部变量、参数值以及返回地址都会被压入栈中，在退回阶段，位于栈顶的局部变量、参数值和返回地址被弹出，用于返回调用层次中执行代码的其他部分，就是恢复了调用的状态。