数据结构学习笔记——栈

栈

栈的顺序存储结构及其基本运算实现

顺序栈

4要素

基于顺序栈的基本运算

共享栈

共享栈的4要素

栈的链式存储结构及其基本运算实现

链栈

4要素

基于链栈的基本运算

栈的定义：

栈是一种只能在一端进行插入或删除的线性表，表中允许进行插入和删除操作的一端称为栈顶，栈顶的当前位置由一个被称为栈顶指针（实际上是一个数字，由于起到了指针一样的作用，故习惯上叫做指针）的位置指示器来指示，另一端称为栈底。栈中没有元素，这种栈就叫做空栈，栈的插入操作叫做进栈，栈的删除操作叫做出栈或退栈。

栈的元素进出特征为后进先出。

栈的顺序储存结构及其基本运算的实现：

栈中的数据元素的逻辑关系呈线性结构，那么可以用顺序表来存储，用一个变量top指向当前的栈顶元素以反映栈中元素的变化。
顺序栈：
采用顺序表存储结构的栈。

表的声明：

typedef int Elemtype;
typedef struct
{
	Elemtype data[maxsize];
	int top; //相当于指针，用于指向，或者说是反映栈顶元素的位置。 
} SqStack; 

如图所示，对于栈指针s所指向的栈，(a)表示初始情况，它是一个空栈。(b)表示一个元素a进入栈后，栈的状态。©表示b,c,d进入栈后，栈的状态。(d)表示d出栈后，栈的状态。由上可知，栈的变化主要是top指针的变化。

四要素：
综上所述，s所指的顺序栈在初始时设置s -> top = -1,可以归纳出对后面算法设计来说非常重要的4个要素。
栈空的条件：s -> top == -1
栈满的条件：s -> top == maxsize -1（data数组的最大下标）
元素e进栈的操作：先将栈顶指针top自增1，然后将元素e放到栈顶指针处。
出栈操作：先将栈顶指针所指的元素取出放到e中，然后让栈顶指针自减1。

基于顺序栈的基本运算
初始化栈
C:

SqStack* InitStack()
{
	s = (SqStack *)malloc(sizeof(SqStack));
	s -> top = -1;
 } 

C++:

void (SqStack * &s)
{
	s = (SqStack *)malloc(sizeof(SqStack));
	s -> top = -1;
}

销毁栈：
C:

_Bool DestroyStack(SqStack *s)
{
	if (s -> top != -1) 
	{
		free(s);
		return 1;
	}
	else return 0;
}//设置为_Bool类型纯属为了算法的健壮性

C++:

void DestroyStack(SqStack *&s)
{
	free(s);
}

进栈：
基本思想就是先让top指针自增1，然后再新的位置插入元素。
C:

_Bool Push(SqStack *s,Elemtype e)
{
	if (s -> top == maxsize - 1) 
		return 0;
	else
	{
		s -> top ++;
		s -> data[s -> top] = e;//s -> data[++ top} = e;
		return 1;
	}
}

C++:

bool Push (SqStack * &s,Elemtype e)
{
	if (s -> top == maxsize -1) return false;
	else
	{
		top ++;
		s -> data[s -> top] = e;
		return true;
	}
}

注意了，不能够直接用s -> data[top] = e这样的形式，因为在函数中没有top这个变量的定义，只有结构体中才有。

出栈：
其基本思想是，首先把栈顶元素赋给变量e，然后top指针自减1，注意这里并没有删除或者是说free掉，只要栈还在并且没有插入，那么这个出栈的元素将一直存在与它原先存在的位置，所以可以利用这点进行还原。
C:

_Bool Pop(SqStack *s, Elemtype e)
{
	if (s -> top == -1) return 0;
	else
	{
		e = s -> data[s -> top];
		s -> top --;
		return 1;
	}
}

C++:

bool Pop(SqStack * &s, Elemtype &e)
{
	if (s -> top == -1) return false;
	else
	{
		e = s -> data[s -> top];
		s -> top--;
		return true;
	}

取栈顶元素：
在栈不为空的情况下把栈顶元素读取出来赋给e，返回真，否则返回假。
C:

_Bool Pop(SqStack *s, Elemtype *e)
{
	if (s -> top == -1) return 0;
	else
	{
		*e = s -> data[s -> top];
		return 1;
	}
}

C++:

bool Pop(SqStack *s,Elemtype &e)
{
	if (s -> top == -1) return false;
	else
	{
		e = s -> data[s -> top];
		return true;
	}
}

共享栈
对于两个相同数据类型的栈，如果一个栈的利用率较少，而另一个就要满了，这样子就感觉不好，怎么把空间利用起来呢，共享栈可以 解决这个问题。
用一个数组来实现两个栈，这称为共享栈。

数组有两个端，左边端作为栈1的栈底，即下标为0处，另一个作为栈2的栈底，即下标为MaxSize-1处。这样在两个栈中进栈元素时，栈顶元素的位置向中间靠拢。

4要素
1.栈空条件，栈1：top1 == -1,栈2：top2 == MaxSize.
2.栈满条件：top1 == top2 -1.
3.元素x进栈操作：进栈1：栈顶指针自增1，输入；栈2：栈顶指针自减1，输入。
4.出栈操作：栈1：读取，栈顶指针自减1；栈2：读取，栈顶指针自增1.

共享栈的类型声明

typedef struct
{
	Elemtype data[maxsize];
	int top1,top2;
} DStack;

基于链栈的基本运算：
1.链栈的定义：采用链式存储结构的栈。
链栈的优点是不存在栈满，规定链栈的所有操作都是在单链表的头结点旁进行的。
链栈中结点类型声明：

typedef struct linknode
{
	Elemtype data;
	linknode *next;
 } LinkStNode;

4要素：
1.栈空的条件：s -> next = NULL
2.栈满的条件：不存在。
3.元素e进栈的操作：新建一个结点（由p指向它）存放e，再用尾插法把p插入到头结点之后。
4.出栈操作：取出首结点的值并删除。
基于链栈的基本操作：
1. 初始化栈：
创建一个空栈，指针域设置为NULL。
C:

LinkStNode* InitStack()
{
	LinkStNode *s;
	s = (LinkStNode *)malloc(sizeof(LinkStNode));
	s -> next = NULL;

	return s;
}

C++:

void InitStack(LinkStNode * &s)
{
	s = (LinkStNode *)malloc(sizeof(LinkStNode));
	s -> next = NULL;
}

**2.**销毁栈：
C:

void DestroyStack(LinkStNode *s)
{
	LinkStNode *pre,*p;
	
	pre = s;
	p = pre -> next;
	while(p != NULL)
	{
		free(pre);
		pre = p;
		p = pre -> next;
	}//销毁了一个结点
	
	free(pre); 
}

C++:

void DestroyStack(LinkStNode *&s)
{
	LinkStNode *pre,*p;
	pre = s;
	p = pre -> next;
	while(p != NULL)
	{
		free(pre);
		pre = p;
		p = pre -> next;
	}
	free(pre);
}

**3.**判断栈是否为空：
C:

_Bool StackEmpty(LinkStNode *s)
{
	return (s -> next == NULL);
}

C++:

bool StackEmpty(LinkStNode *s)
{
	return (s -> next == NULL);
}

**4.**进栈：
创建一个新结点，数据域放置要存进去的数据，然后把结点的指针域存放当前首结点的地址，然后把头结点的指针域存放新结点的地址。
C:

void Push(LinkStNode *s,Elemtype e)
{
	LinkStNode *node;
	node = (LinkStNode *)malloc(sizeof(LinkStNode));
	node -> data = e;
	node -> next = s -> next;
	s -> next = node;
}

C++:

void Push(LinkStNode *&s,Elemtype e)
{
	LinkStNode *node;
	node = (LinkStNode *)malloc(sizeof(LinkStNode));
	node -> data = e;
	node -> next = s -> next;
	s -> next = node;
}

**5.**出栈：
在不是空栈的情况下把栈顶元素赋给变量e，然乎删除栈顶元素。
C:

_Bool Pop (LinkStNode *s,Elemtype *e)
{
	if (s -> next == NULL) return 0;
	else
	{
		LinkStNode *p;
		p = s -> next;
		*e = p -> data;
		s -> next = p -> next;
		free(p);
		return 1;
	}
}

C++:

bool Pop(LinkStNode * &s, Elemtype &e)
{
	if (s -> next == NULL) return false;
	else
	{
		LinkStNode *p;
		p = s -> next;
		e = p -> data;
		s -> next = p -> next;
		free(p):
		return true;
	}
}

**6.**取栈顶元素：
在栈不为空的情况下把栈顶元素赋给引用型参数e。
C:

_Bool GetTop(LinkStNode *s,Elemtype *e)
{
	if (s -> next == NULL) return 0;
	else
	{
		*e = s -> next -> data;
		return 1;
	}
}

C++:

bool GetTop(LinkStNode *s,Elemtype &e)
{
	if (s -> next == NULL) return false;
	else
	{
		e = s -> next -> data;
		return true;
	}
}