栈顺序存储&链式存储

1.栈的顺序存储之动态存储

#include<stdio.h>
#include<stdlib.h>

#define OK 1
#define FALSE 0
#define TRUE 1
#define STACK_INIT_SIZE 20 //存储空间初始分配量
#define STACKINCREMENT 5 //存储空间分配增量

typedef int SELemType;
typedef int Status;
typedef struct
{
	SELemType *base;
	SELemType *top;
	int stacksize;	//当前已分配的存储空间
}SqStack;

Status InitStack(SqStack *S)//构造一个空栈
{
	S->base = (SELemType *)malloc(STACK_INIT_SIZE*sizeof(SELemType));
	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
	return OK;
}

Status Push(SqStack *S, SELemType e)//入栈
{
	if (S->top - S->base >= S->stacksize)
	{
		S->base = (SELemType *)realloc(S->base, (S->stacksize + STACKINCREMENT)*sizeof(SELemType));
		if (!S->base) exit(0);
		S->top = S->stacksize+S->base;
		S->stacksize += STACKINCREMENT;
	}
	*(S->top) = e;
	S->top++;//插入新元素后，top指针+1
	return OK;
}


Status GetTop(SqStack *S, SELemType *e)//用e返回栈顶元素
{
	if (S->top == S->base) return FALSE;//栈为空
	*e = *(S->top -1);
	return OK;
}

Status Pop(SqStack *S,SELemType *e)//删除栈顶元素，用e返回其值
{
	if (S->top == S->base) return FALSE;
	*e = *(S->top - 1);
	S->top--;
	return OK;
}

int StackLength(SqStack *S)
{
	return S->top - S->base; //地址指针相减，结果并不是地址差，而是实际元素的差值。
}
Status ClearStack(SqStack *S)
{
	S->top = S->base;
	return OK;
}

Status DestroyStack(SqStack *S)
{
	free(S->base);
	S->base = S->top = NULL;
	S->stacksize = 0;
	return OK;
}

int main()
{
	SqStack S;
	int cord;
	Status result;
	do
	{
		printf("\n1.初始化栈\n");
		printf("2.入栈\n");
		printf("3.输出栈顶元素\n");
		printf("4.删除栈顶元素\n");
		printf("5.元素个数即栈的长度\n");
		printf("6.清空栈\n");
		printf("7.销毁栈\n");
		scanf_s("%d", &cord);
		switch (cord)
		{
			case 1:
			{
				  result = InitStack(&S);
				  if (result == OK)printf("初始化栈成功\n");
				  else printf("初始化失败\n");
			}break;
			case 2:
			{
					  int e;
				    printf("输入要插入的元素e\n");
					scanf_s("%d", &e);
			        result = Push(&S, e);
					if (result == OK)printf("成功插入%d\n", e);
					else printf("初始化失败\n");
			}break;
			case 3:
			{
					  int e;
					  result = GetTop(&S, &e);
					  if (result == OK)  printf("栈顶元素为%d\n", e);
					  else printf("空栈");
			}break;
			case 4:
			{
					  int e;
					  result = Pop(&S, &e);
					  if (result == OK) printf("栈顶元素%d已删除\n", e);
					  else  printf("空栈");
			}break;
			case 5:
			{
					  int length;
					  length = StackLength(&S);
					  printf("栈的长度为%d\n", length);
			}break;
			case 6:ClearStack(&S); break;
			case 7:DestroyStack(&S); break;
		
		}
	} while (cord > 0 && cord <= 7);
	return 0;
}

另一种较简单的写法

//用数组的话不用销毁，没用指针不用销毁，好像是自动销毁
<pre name="code" class="cpp">#include<stdio.h>  
#include<stdlib.h>  
#define MAX 20  

typedef struct SqStack
{
	int elem[MAX];
	int top;//栈顶指针  
}SqStack;
int InitStack(SqStack *S)
{
		S->top = -1; printf("置空栈成功\n");

	return 1;
}
int Push(SqStack *S)
{
	//在栈顶插入新元素x，返回1表示入栈成功，返回0表示失败  
	int n;
	if (S->top == MAX - 1){ printf("栈满不能入栈\n"); return 0; }
	else
	{
		printf("输入要入栈的数据个数"); scanf_s("%d", &n);
		printf("输入要入栈的元素: ");
		while (S->top < n - 1)
		{
			S->top++;
			scanf_s("%d", &(S->elem[S->top]));
		}
		printf("Push success\n");
		return 1;
	}
}
int Get_SqStack(SqStack *S, int *e)
{
	//用e栈顶元素，成功返回1，失败返回0  
	if (S->top == -1){ printf("栈是空的"); return 0; }
	else
		*e = S->elem[S->top];
	return 1;
}
int Pop_SqStack(SqStack *S, int *e)
{
	//删除栈顶元素，用tmp返回其值，返回值为1表示出栈成功，为0表示出栈失败  
	if (S->top == -1){ printf("栈是空的"); return 0; }
	else (*e = S->elem[S->top]);
	S->top--;
	return 1;
}
void outline(SqStack *S)
{
	for (int i = S->top; i >= 0; i--)
		printf("%2d", S->elem[i]);
}
int main()
{
	int cord, data, flag;
	SqStack S;
	do{
		printf("\n1栈的初始化     \n");
		printf("2数据入栈   \n");
		printf("3出栈 \n");
		printf("4取栈顶元素\n");
		printf("5输出栈中元素\n");
		scanf_s("%d", &cord);
		switch (cord)
		{
		case 1:{  InitStack(&S);   }break;
		case 2:{  Push(&S); }break;
		case 3:{
				   flag = Pop_SqStack(&S, &data);
				   if (flag == 1)printf("出栈的元素为%d", data);
		}break;
		case 4:{  flag = Get_SqStack(&S, &data);
			if (flag == 1)printf("当前栈顶元素为%d", data);
		}break;
		case 5:{  outline(&S); }break;

		}
	} while (cord <= 5 && cord > 0);
	return 0;
}

 

栈的链式存储（双结构体）

#include <stdio.h>
#include <stdlib.h>
#define Status int
#define OK 1

typedef struct StackNode//定义栈结点的结构
{
	int data;
	struct StackNode *next;
}StackNode;

typedef struct LinkStack//定义栈
{
	StackNode *top;
	int count;
}LinkStack;

Status Initlist(LinkStack *S2)//初始化栈
{
	S2->top = (StackNode *)malloc(sizeof(StackNode));
	//S2 = (LinkStack *)malloc(sizeof(LinkStack));
	S2->top = NULL;
	S2->count = 0;
	return OK;
}
Status Push(LinkStack *S2, int x)//入栈
{
	StackNode *p;
	p = (StackNode *)malloc(sizeof(StackNode));
	p->data = x;
	p->next = S2->top;
	S2->top = p;
	S2->count++;
	return OK;
}

Status Pop(LinkStack *S2, int *e)//删除栈顶元素，用e返回其值
{
	StackNode *p;
	*e = S2->top->data;
	p = S2->top;
	S2->top = S2->top->next;
	free(p);
	S2->count--;
	return OK;
}
Status StackEmpty(LinkStack *S2)//判断栈空
{
	if (S2->count == 0) return 1;
	else return 0;
}
Status ClearStack(LinkStack *S2)
{
	StackNode *p, *q;
	p = S2->top;
	while (p)
	{
		q = p;
		p = p->next;
		free(q);
	}
	S2->count = 0;
	return OK;
}
void Outline(LinkStack *S2)
{
	StackNode *p;
	p = S2->top;
	while (p)
	{
		printf(" %d ", p->data);
		p =p->next;
	}
	printf("\n");
}
int main()
{
	int cord, result;
	LinkStack S2;
	do
	{
		printf("\n1.初始化\n");
		printf("2.入栈\n");
		printf("3.出栈\n");
		printf("4.显示\n");
		printf("5.置空栈\n");
		printf("6.判栈空\n");
		scanf_s("%d", &cord);
		switch (cord)
		{
		case 1:
		{
				  result = Initlist(&S2);
				  if (result == OK) printf("初始化成功\n");
		}break;
		case 2:
		{
				  int x;
				  printf("输入要入栈的元素：");
				  scanf_s("%d", &x);
				  result = Push(&S2, x);
				  if (result == OK) printf("成功入栈\n");
		}break;
		case 3:
		{
				  int e;
				  result = Pop(&S2, &e);
				  if (result == OK)printf("元素%d出栈\n", e);
		}break;
		case 4:
		{
				  Outline(&S2);
		}break;
		case 5:if (ClearStack(&S2) == OK) printf("清空栈成功\n"); break;
		case 6:
		{
				  result = StackEmpty(&S2);
				  if (result == OK)
				  printf("是空栈\n"); 
				  else
					  printf("不是空栈\n");
		}break;
		}
	} while (cord<9);

	return 0;
}