栈的定义（线性结构）；顺序存储实现；链式存储实现

定义

• 线性表是具有相同数据类型的n个数据元素的有限序列，其中n是表长，当n=0时线性表是空表。若用L明明线性表，则一般表示为
  $$L=(a_1,a_2,...,a_i,a_{i+1},...,a_n)$$
• 栈（Stack）是一种只允许在一端进行插入或删除操作的线性表。
• 特点：后进先出
  Last In First Out(LIFO)

重要术语

• 栈顶：允许插入和删除的一端 -栈顶元素
• 栈底：不允许插入和删除的一端 -栈底元素
• 空栈

数学性质

创增删查的时间复杂度都是O(1)

基本操作

线性表

• InitList(&L)
• DestroyList(&L)
• ListInsert(&L,i,e)
• ListDelete(&L,i,&e)
• LocateElem(L,e)
• GetEle(L,i)
• Length(L)
• PrintList(L)
• Empty(L)

栈

• InitStack(&S)：初始化栈。构造一个空栈，分配内存空间
• DestoryStack(&S)：销毁栈。销毁并释放栈S所占用的内存空间
• Push(&S,x)：入栈。若栈s未满，则将x加入栈并使之称为新栈顶。
• Pop(&S,&x)：出栈。若栈s非空，则弹出栈顶元素，并用x返回。
• GetTop(S,&x)：读取栈顶元素。若栈S非空，则用x返回栈顶元素。
• StackEmpty(S)：判断栈S是否为空，若为空则返回true，否则false。

合法的出栈顺序

组合数学结论

n个不同元素入栈，合法的出栈顺序数为
$$\frac{1}{n+1}=\left(\genfrac{}{}{0ex}{}{n}{2n}\right)$$

合法性模拟法判判断

（例）设栈的入栈序列是 1 2 3 4，则下列不可能是其出栈序列的是（ ）。
A. 1 2 4 3
B. 2 1 3 4
C. 1 4 3 2
D. 4 3 1 2
E. 3 2 1 4

模拟法：
入栈
1234
出栈

• 1234
  $$[i_1,o_1,i_2,o_2,i_3,o_3,i_4,o_4]$$
• 1243
  $$[i_1,i_2,i_3,i_4,o_4,o_3,o_2,o_1]$$
• 4312
  $$[i_1,i_2,i_3,i_4,o_4,o_3]$$
  此时栈顶是2，无法实现o_1，所以选D

入栈
12345
出栈

• 53124
  $$[i1,i2,i3,i4,i5,o5]$$
  此时栈顶为4，无法实行o_3

顺序栈的实现

顺序栈的定义

#define MaxSize 10				//定义栈中最大元素个数
typedef struct{					
	ElemType data[MaxSize]; 	//静态数组存放栈中元素
	int top;					//栈顶指针
}SqStack;						//SquenceStack

顺序栈的操作

• 初始化
• 进栈
• 出栈
• 读取栈顶元素

栈顶指针初始化为-1

//栈顶指针初始化为-1
#define MaxSize 10
typedef struct{
	Elemtype data[MaxSize];
	int top;
}SqStack;

//初始化栈
void InitStack(SqStack *S){
	S -> top =	-1;
}

//判空
bool Empty(SqStack *S){
	if(S -> top == -1)return true;
	return false;	
}

void testStack(){
	SqStack S;
	InitStack(&S);
}

//新元素进栈
bool Push(SqStack &S,EleType e){
	if(S.top == MaxSize - 1)return false;
	S.data[++S.top] = e;
	return true;
}

//出栈操作
bool Pop(SqStack &S,Element &e){
	if(S.top == -1)return false;
	e = S.data[S.top--];
	return ture;
}

//读取栈顶元素
bool GetTop(SqStack &S,Element &e){
	if(S.top  == -1)return false;
	e = S.data[S.top];
	return true;
}

int main(){
	SqStack S;
	ElemType x;
	ElemType y;
	InitStack(S);
	Push(S,x);
	GetTop(S,&y);
	Pop(S,y);
	Empty(S);
	return 0;
}

栈顶指针初始化为0

//栈顶指针初始化为0
#define MaxSize 10
typedef struct{
	ElemType data[MaxSize];
	int top;
}SqStack;

bool InitStack(SqStack &S){
	if(S == NULL)return false;
	S.top = 0;
	return true;
}

bool Push(SqStack &S,ElemType e){
	if(S.top == MaxSize)return false;
	S.data[S.top++] == e;
	return true;
}

bool Pop(SqStack &S,ElemType &e){
	if(S.top == 0)return false;
	e = S.data[--S.top];
	return true;
}

bool GetTop(SqStack S,ElemType &e){
	if(S.top == 0)return false;
	e = S.data[S.top - 1];
	return true;
}

共享栈

#define MaxSize 10

typedef struct{
	elemType data[MaxSize];
	int top0,top1;
}ShStack;

//初始化栈
void InitShStack(ShStack &S){
	S.top0 = -1;
	S.top1 = MaxSize;
}

//判空
bool EmptyStack(ShStack S){
	if(S.top0 == -1&& S.top1 == MaxSize)return true;
	return false;
}

//判满
bool FullStack(ShStack S){
	if(S.top0 + 1 == S.top1)return ture;
	return false;
}

链栈的实现

带头节点

typedef struct LinkNode{
	ElemType data;
	struct LinkNode *next;
} LNode,*LiStack;

//初始化
void InitStack(LiStack &L){
	L = (LNode *)malloc(sizeof(LNode));
	if(L == NULL)return false;
	L -> next == NULL;
	return ture;	
}

//判空
bool EmptyLiStack(LiStack L){
	if(L -> next == NULL)return true;
	return false;
}

//??
bool FullLiStack(LiStack L){
}

//进栈
bool Push(LiStack L,ElemType e){
	LNode *p = (LNode *)malloc(sizeof(LNode));
	if(p == NULL)return false;
	p -> data = e;
	p -> next = L -> next;
	L -> next = p;
	return	true;
}

//出栈
bool Pop(LiStack L,ElemType &e){
	if(L -> next == NULL)return false;
	LNode *p = L -> next;
	e = p -> data;
	L -> next = p -> next;
	free(p);
	return true;
}

//获取栈顶元素
bool GetTop(LiStack L,ElemType &e){
	if(L -> next == NULL)return false;
	e = L -> next -> data;
	return false;	
}

不带头节点

typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode,* LiStack;

void InitLiStack(LiStack L){
	L = NULL;
}

bool EmptyStack(LiStack L){
	if(L == NULL)return true;
	return false;
}

bool Push(LiStack &L,ElemType x){
	if(L = NULL){
		L = (LiStack)malloc(sizeof(LNode));
			if(L == NULL)return true;
		L -> data = e;
		L -> next = NULL;
	}else{
		LNode *p = (LNode *)malloc(sizeof(LNode));
		p -> data = e;
		p -> next = L -> next;
		L -> next = p;
	}
	return ture
}

bool Pop(LiStack &L,ElemType &x){
	if(L == NULL)return false;
	x = L -> data;
	LNode *p = L;
	L = L -> next;
	free(p);
	return true;
}

bool GetTop(LiStack L,ElemType &x){
	if(L == NULL)return false;
	x = L -> data;
	return ture;
}