栈 顺序和链式

#define Maxsize 20
#include<stdio.h>
#include<stdlib.h>
#define Elemtype int
typedef struct {
	int stacksize;//指当前栈的存储最大容量
	Elemtype* base;//开始指向栈底元素
	Elemtype* top;//指向栈顶元素的下一个位置
}Sqstack;
void Traverse(Sqstack S) {
	printf("\n栈中元素为");
	for (Elemtype* p = S.base; p < S.top; p++) {
		printf("%d ", *p);
	}
}
void InitStack(Sqstack& S) {
	S.base = new Elemtype[Maxsize];
	if (!S.base)
		return;
	S.top = S.base;
	S.stacksize = Maxsize;
}
bool StackEmpty(Sqstack S) {
	return(S.top == S.base);
}
int StackLength(Sqstack S) {
	return (S.top - S.base);
	//两个指针相减表示的是这两个指针所对应的地址之间在内存中相隔多少
}
void Push(Sqstack& S, int e) {
	if (S.top - S.base == S.stacksize)
		return;
	*S.top = e;
	*S.top++;
}
int GetTop(Sqstack S, int &e) {
	if (StackEmpty(S))
		return 0;
	e = *(S.top-1);
	return e;
}
void Pop(Sqstack& S, int& e) {
	if (StackEmpty(S))
		return;
	e = *S.top - 1;
	S.top--;
}
void DestroyStack(Sqstack& S) {
	if (S.base) {
		delete S.base;
		S.stacksize = 0;
		S.top = NULL;
		S.base = NULL;
	}	
}
void ClearStack(Sqstack& S) {
	if (S.base)
		S.top = S.base;
}
bool StackFull(Sqstack& S) {
	return (StackLength(S) == S.stacksize);
}
int main() {
	int n;
	int e;
	Sqstack S;
	InitStack(S);
	printf("请输入栈中元素个数:\n");
	scanf_s("%d", &n);
	for (int i = 0; i < n; i++) {
		printf("栈中第%d个元素为:\n", i + 1);
		scanf_s("%d", &e);
		Push(S, e);
	}
	Traverse(S);
	printf("栈顶元素为%d\n", GetTop(S, e));
	Pop(S, e);
	Traverse(S);
	printf("Stacklength=%d\n", StackLength(S));
	ClearStack(S);
	Traverse(S);
	if (StackFull(S))
		printf("\n满栈");
	else
		printf("\n非满栈");
}

算法分析：

        Push：就是向栈中压入一个元素 同时top指针上移

        Pop：将栈中top元素弹出 此时top指针下移 将*top赋给新元素

        GetTop:只获取top元素的值

        StackLength: 由于top指针指向top原宿的上方一个元素 而base指向最底下的元素

                所以在求长度时只需要将二者相减 返回ElemType对应的指针相差的倍数 即长度

出入栈顺序：

        如果一个栈的输入序列为123456，能否得到435612和135426的出栈序列？

需要注意的是 进栈顺序和出栈顺序不可以相同 如435612中的12就不符合 只可以逆序

链栈：

        与顺序栈相比 链栈不会存在内存溢出或者栈容量不够的情况 其本质还是一个单链表

 要使用头插法来模拟入栈

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define Elemtype char
typedef struct node{
	Elemtype data;
	struct node* next;
}StackNode,*LinkStack;
void InitStack(LinkStack& S) {
	S = NULL;
}
//头插法 模拟栈原理
void Push(LinkStack& S, char c) {
	StackNode* p = new StackNode;
	if (!p){
		exit(OVERFLOW);
		printf("内存不足");
}
	p->data= c;
	p->next=S;
	S = p;
	return;
}
bool StackEmpty(LinkStack S) {
	return (S == NULL);
}
char Pop(LinkStack& S, char& c) {
	LinkStack p;
	p = S;
	c = S->data;
	S = S->next;
	delete p;
	return c;
}
char GetTop(LinkStack S, char& c) {
	if (StackEmpty(S))
		return 'NULL';
	c = S->data;
	return c;
}
void ClearStack(LinkStack& S) {
	while (S!= NULL)
		S = NULL;
}
void DestroyStack(LinkStack& S) {
	while (S!= NULL) {
		S = NULL;
		delete S;
	}
}
void Traverse(LinkStack S) {
	if (S == NULL)
		printf("\n空栈");
	while (S!= NULL){
		printf("%c ", S->data);
		S = S->next;
	}
}
int main() {
	char c;
	LinkStack S;
	InitStack(S);
	Push(S, '1');
	Push(S, '2');
	Push(S, '3');
	Push(S, '4');
	Traverse(S);
	printf("弹出元素%c", Pop(S, c));
	printf("\n栈顶元素为%c ", GetTop(S, c));
	ClearStack(S);
	Traverse(S);
}