c语言建立栈（顺序栈、双栈和链式栈）

顺序存储

我们采用的是动态分配方式来定义顺序存储。

顺序栈本质上是顺序表的简化，由于栈底位置是不变的，所以可以将栈底位置设置在存储空间的基地址上，站定位置随着元素的增删而变化，故用top来指示当前栈顶元素的下一个位置，通常称top为栈顶指针。

有以下几点声明：

1. 赋值操作：*s->top = val;
2. 栈为空：s->top == s->base
3. 栈满：s->top-s->base >=stacksize

栈的顺序存储定义

#define MAXSTACKSIZE 100
#define STACKINCREMENT 10

typedef struct {
	int* base;
	int* top;
	int stacksize;
}SqStack;

初始化栈

SqStack* InitStack_Sq() {
	SqStack* s;
	s = (SqStack*)malloc(sizeof(SqStack)); //记得申请空间
	s->base = (int*)malloc(MAXSTACKSIZE *sizeof(int));
	if (!s->base) {
		printf("内存分配失败\n");
		return 0;
	}
	//同时指向一个位置
	s->top = s->base;
	s->stacksize = MAXSTACKSIZE;
	return s;
}

入栈操作

//入栈
void Push_Sq(SqStack* s, int val) {
	if (s->top - s->base >= s->stacksize) { //满栈了
		s->base = (int*)realloc(s->base,sizeof(int) * (MAXSTACKSIZE + STACKINCREMENT));
		if (!s->base) {
			printf("内存分配失败\n");
			return;
		}
		s->stacksize += STACKINCREMENT;
		s->top = s->base;
	}
	*s->top = val;
	s->top++;
	// *s->top++ = val;
}

出栈操作

//出栈
// s->top 指向的是栈顶的下一个，所以要先减，再取值
int Pop_Sq(SqStack* s) {
	if (s->base == s->top) {
		printf("队列为空\n");
		return 0;
	}
	int val = *(--s->top);
	return val;
}

其余操作

读取栈顶元素

//读取栈顶
int Top_Sq(SqStack* s) {
	if (s->base == s->top) {
		printf("队列为空\n");
		return 0;
	}
	return *(s->top - 1);
}

栈中元素个数

//返回栈中元素个数
int stackLength(SqStack* s) {
	return s->top - s->base;
}

栈是否为空

//判断栈是否为空
int empty_sq(SqStack* s) {
	if (s->base == s->top)
		return 1;
	else
		return 0;
}

双栈

MAXSTACKSTZE为整个数组空间的长度，栈1的底端固定在下标为0的一端，栈2的底端固定在下标为MAXSTACKSIZE -1 的一端。 top⁡1 和 top2分别为栈1和栈2的栈顶指针，并约定栈顶指针指向当前元素，即栈1空的条件是 top1=−1,栈1满的条件top1=top⁡2−
1，栈2空的条件是 top⁡2=MAXSTACSIZE,栈2满的条件是 。top2=top1+1。

双栈的顺序存储结构定义

#define MAXSTACKSIZE 100

typedef struct {
	int data[MAXSTACKSIZE];
	int top1, top2;
}doubleStack;

建立双栈

//建立双栈
doubleStack* init() {
	doubleStack* s;
	s = (doubleStack*)malloc(sizeof(doubleStack));
	s->top1 = -1;
	s->top2 = MAXSTACKSIZE;
	return  s;
}

判断栈为空

//flag = 1 是栈1，flag = 2 是栈2
int empty_D(doubleStack* s,int flag) {
	if (flag == 1) {
		if (s->top1 == -1)
			return 1;
		else
			return 0;
	}
	else {
		if (s->top1 == MAXSTACKSIZE)
			return 1;
		else
			return 0;
	}
}

进栈操作

//进栈
void Push_D(doubleStack* s, int flag, int val) {
	if (s->top1 + 1 == s->top2) {
		printf("栈已满\n");
		return;
	}
	if (flag == 1) // 对栈一进行操作
		s->data[++s->top1] = val; //先使栈1的顶指针增加1，再将元素插入
	else
		s->data[--s->top2] = val; //先使栈2的顶指针减1，再将元素插入
}

出栈操作

// 出栈
// 指针移动就相当于删除操作
int Pop_D(doubleStack* s, int flag) {
	if (flag == 1) {
		if (s->top1 == -1) {
			printf("栈为空\n");
			return;
		}
		int val = s->data[s->top1--]; //先删除栈顶元素，再讲栈顶指针减1
		return val;
	}
	else {
		if (s->top1 == MAXSTACKSIZE) {
			printf("栈为空\n");
			return;
		}
		int val = s->data[s->top1++];//先删除栈顶元素，再讲栈顶指针加1
		return val;
	}
}

链式栈

前言

链式存储表示

若是栈中元素的数目变化范围较大或不清楚栈元素的数目，就应该考虑使用链式存储结构。人们将用链式存储结构表示的栈称作“链栈”。

链栈通常用一个无头结点的单链表表示。由于栈的插入、删除操作只能在一端进行，而对于单链表来说，在首端插入、删除结点要比在尾端进行相对容易一些，所以将单链表的首端作为栈的顶端，即将单链表的头指针作为栈顶指针。

typedef struct SNode {
	int data; //数据域
	SNode* next; //链域
}SNode,*LinkStack;
LinkStack top; //栈顶指针

进栈操作

void init(LinkStack &top) {
	top = NULL; 
}

//进栈操作
void Push_L(LinkStack &top, int val) {
	SNode* node = (LinkStack)malloc(sizeof(SNode));
	if (!node) {
		printf("申请空间失败\n");
		return;
	}
	node->data = val;
	node->next = top; //因为刚开始是空的，所以栈底元素指向的下一个元素为空
	top = node; //栈顶指针指向新节点
}

出栈操作

//出栈操作
int Pop_L(LinkStack &top) {
	if (!top) {
		printf("栈为空\n");
		return 0;
	}
	int val = top->data;
	SNode* p = top;
	top = top->next; //修改栈顶指针，将栈顶节点从链上摘下
	free(p);
	return val;
}

取栈顶元素

//取栈顶元素
int Top_L(LinkStack top) {
	if (!top) {
		printf("栈为空\n");
		return;
	}
	int val = top->data; //取栈顶元素
	return val;
}

置空栈

//栈置空
void Clear_L(LinkStack &top) {
	while (top) {
		SNode* p = top;
		top = top->next;
		free(p);
		p = NULL;
	}
}