数据结构——栈

一、栈的定义

       栈是限定仅在表尾进行插入和删除操作的线性表。

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

       栈的插入操作，叫作进栈，也称压栈、入栈；栈的删除操作，叫作出栈，有的也叫作弹栈。

二、栈的抽象数据类型

三、栈的顺序存储结构及实现

栈的顺序存储结构

       既然栈是线性表的特例，那么栈的顺序存储其实也是线性表顺序存储的简化，我们称为顺序栈。 定义一个top变量来指示栈顶元素在数组中的位置，若存储栈的长度为StackSize，则栈顶位置top必须小于StackSize。当栈存在一个元素时，top等于0，因此通常把空栈的判定条件定位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++;					/* 栈顶指针增加一 */
    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--;				/* 栈顶指针减一 */
    return OK;
}

四、两栈共享空间

       如果我们有两个相同类型的栈，我们为它们各自开辟了数组空间，极有可能是第一个栈已经满了，再进栈就溢出了，而另一个栈还有很多存储空间空闲。我们完全可以用一个数组来存储两个栈，充分利用这个数组占用的内存空间。

       数组有两个端点，两个栈有两个栈底，让一个栈的栈底为数组的始端，即下标为0处，另一个栈为数组的末端，即下标为数组长度n-1处。这样，两个栈如果增加元素，就是两端点向中间延申。

       栈1为空时，就是top1等于-1时；而当top2等于n时，即是栈2为空时。若栈2是空栈，栈1的top1等于n-1时，就是栈1满了；反之，当栈1为空栈时，top2等于0时，栈2满。但更多的情况，两个栈见面之时，也就是两个指针之间相差1时，即top1+1 == top2为栈满。

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

插入

/* 插入元素e为新的栈顶元素 */
Status Push(SqDoubleStack *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;
}

删除

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

五、栈的链式存储结构及实现

        通常对于链栈来说，是不需要头结点的。

/* 链栈结构 */
typedef struct StackNode
{
    SElemType data;
    struct StackNode *next;
}StackNode,*LinkStackPtr;


typedef struct
{
    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赋值给栈顶指针，见图中② */
    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;
}

       如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。

六、栈的作用

        栈的引入简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的问题核心。而像线性表顺序存储结构用到的数组，因为要分散精力去考虑数组的下标增减等细节问题，反而掩盖了问题的本质。

七、栈的应用——递归

对于斐波那契数列，如果我们用数学函数来定义就是：

迭代对斐波那契数列的前四十位进行打印 

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[i-2];  
		printf("%d ",a[i]);  
	} 

递归对斐波那契数列的前四十位进行打印

/* 斐波那契的递归函数 */
int Fbi(int i)  
{
	if( i < 2 )
		return i == 0 ? 0 : 1;  
    return Fbi(i-1)+Fbi(i-2);  /* 这里Fbi就是函数自己，等于在调用自己 */
}  

int main()
{
	int i;
	printf("递归显示斐波那契数列：\n");
	for(i = 0;i < 40;i++)  
		printf("%d ", Fbi(i));  
    return 0;
}

当i=5,执行过程为

 

递归的定义

        我们把一个直接调用自己或通过一系列的调用语句简介调用自己的函数，称作递归函数。每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值退出。 迭代和递归的区别是：迭代使用的是循环结构，递归使用的是选择结构。递归能使程序的结构更清晰、更简洁、更容易让人理解，从而减少读懂代码的时间。但是大量的递归调用会建立函数的副本，会耗费大量的时间和内存。迭代则不需要反复调用函数和占用额外的内存。