顺序栈和链栈

1.顺序栈

代码实现：

//#pragma once				//作为头文件时加上这行
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define DataType int
#define STACK_MAXSIZE 30
typedef struct {
	DataType stack[STACK_MAXSIZE];
	int top;	//栈顶，为0时表示栈空，为STACK_MAXSIZE+1时表示栈满
}SeqStack;

/*初始化栈*/
void StackInit(SeqStack* s);

/*判断栈，非空返回1，空返回0*/
int StackNotEmpty(SeqStack* s);

/*元素x入栈，成功返回1，失败返回0*/
int StackPush(SeqStack* s, DataType x);

/*出栈，将元素保存在x，成功返回1，失败返回0*/
int StackPop(SeqStack* s, DataType *x);

/*取栈顶，将元素保存在x，成功返回1，失败返回0*/
int StackTop(SeqStack* s, DataType *x);

void StackInit(SeqStack* s)
{
	s->top = 0;
}

int StackNotEmpty(SeqStack* s)
{
	if (s->top != 0)return 1;
	else return 0;
}

int StackPush(SeqStack* s, DataType x)
{
	if (s->top == STACK_MAXSIZE+1) {
		printf("栈已满，无法入栈\n");
		return 0;
	}
	s->stack[s->top++] = x;
	return 1;
}

int StackPop(SeqStack* s, DataType *x)
{
	if (StackNotEmpty(s)) {
		s->top--;
		*x = s->stack[s->top];
		return 1;
	}
	printf("栈为空，元素出栈\n");
	return 0;
}
int StackTop(SeqStack* s, DataType *x)
{
	if (StackNotEmpty(s)) {
		*x = s->stack[s->top-1];
		return 1;
	}
	printf("栈中元素为空，栈顶无元素可取\n");
	return 0;
}

测试函数：

void test()
{
	int i,x;
	SeqStack s;
	StackInit(&s);
	printf("依次将0-9入栈，然后出栈\n");
	for(i=0;i<10;i++)
	StackPush(&s,i);
	while(StackNotEmpty(&s))
	{
		StackTop(&s,&x);
		printf("%d ",x);
		StackPop(&s,&x);
	}
}

运行结果：

2.链栈

代码实现：

//#pragma once				//作为头文件时加上这行
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define DataType int
typedef struct stack_node		//链栈的节点 
{
	DataType data;
	struct stack_node* next;
}LinkedStack;

//链栈的实现是带头结点，且头结点相连的一端为栈顶，这样插入和删除操作的时间复杂度为O(1)
//也可不带头结点，但是如果不带头结点，每次插入或删除操作后都会修改头指针

/*初始化栈*/
void StackInit(LinkedStack* s);

/*判断栈，非空返回1，空返回0*/
int StackNotEmpty(LinkedStack* s);

/*元素x入栈*/
void StackPush(LinkedStack* s, DataType x);

/*出栈，将元素保存在x，成功返回1，失败返回0*/
int StackPop(LinkedStack* s, DataType *x);

/*取栈顶，将元素保存在x，成功返回1，失败返回0*/
int StackTop(LinkedStack* s, DataType *x);

/*撤销链栈的内存空间*/
void StackDestory(LinkedStack* s);

void StackInit(LinkedStack* s)
{
	s->next = NULL;
}

int StackNotEmpty(LinkedStack* s)
{
	if (s->next != NULL)return 1;
	else return 0;
}

void StackPush(LinkedStack* s, DataType x)
{
	LinkedStack *p1 = NULL, *p2 = NULL;
	p1 = (LinkedStack*)malloc(sizeof(LinkedStack));
	p1->data = x;
	p2 = s->next;
	p1->next = p2;
	s->next = p1;
}

int StackPop(LinkedStack* s, DataType *x)
{
	LinkedStack *p = NULL;
	if (StackNotEmpty(s)) {
		p = s->next;
		s->next=p->next;
		*x = p->data;
		free(p);
		return 1;
	}
	printf("栈为空，无元素出栈\n");
	return 0;
}

int StackTop(LinkedStack* s, DataType *x)
{
	if (StackNotEmpty(s)) {
		*x = s->next->data;
		return 1;
	}
	printf("栈为空，栈顶无元素可取\n");
	return 0;
}

void StackDestory(LinkedStack* s)
{
	LinkedStack *p1 = NULL, *p2 = NULL;
	p1 = s->next;
	while (p1 != NULL)
	{
		p2 = p1;
		p1 = p1->next;
		free(p2);
	}
	s->next = NULL;
}

测试函数：

void test()
{
	int i,x;
	LinkedStack s;
	StackInit(&s);
	printf("依次将0-9入栈，然后出栈\n");
	for(i=0;i<10;i++)
	StackPush(&s,i);
	while(StackNotEmpty(&s))
	{
		StackTop(&s,&x);
		printf("%d ",x);
		StackPop(&s,&x);
	}
}

运行结果：