【数据结构】C语言实现顺序栈和链式栈

顺序栈

SeqStack.h

#pragma once

#include<stdio.h>

typedef char SeqType;

#define SEQMAXSIZE 1000

typedef struct SeqStack{

	SeqType data[SEQMAXSIZE];
	int     top;
	int     bottom;

}SeqStack;

//初始化栈
void SeqStackInit(SeqStack* seq);
//入栈
void SeqStackPush(SeqStack* seq, SeqType value);
//出栈
void SeqStackPop(SeqStack* seq, SeqType* e);
//销毁栈
void SeqStackDestory(SeqStack* seq);

//打印栈
void PrintStack(SeqStack* seq, char* msg);

SeqStack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqStack.h"

//初始化栈
void SeqStackInit(SeqStack* seq) {

	if (seq == NULL) {
		return;
	}
	seq->top = 0;
	seq->bottom = 0;
}
//入栈
void SeqStackPush(SeqStack* seq, SeqType value) {

	if (seq == NULL) {
		return;
	}
	if (SEQMAXSIZE == seq->top) {
		printf("栈满了！");
		return;
	}
	//开始入栈
	seq->data[++seq->top] = value;
}
//出栈
void SeqStackPop(SeqStack* seq, SeqType* e) {

	if (seq == NULL) {
		return;
	}
	if (seq->top == seq->bottom) {
		printf("栈为空！");
	}
	*e = seq->data[seq->top--];
}

//打印栈
void PrintStack(SeqStack* seq, char* msg) {

	if (seq == NULL) {
		return;
	}
	printf("\n\n\n%s", msg);
	printf("[seq->top]->");
	while (seq->top != 0) {
		printf("[%c]->", seq->data[seq->top--]);
	}
	printf("[bottom]\n");
}

//销毁栈
void SeqStackDestory(SeqStack* seq) {

	if (seq == NULL) {
		return;
	}
	seq->top = seq->bottom;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1

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

#define TITLE printf("--------------%s-------------\n",__FUNCTION__)

void TestPush() {
	SeqStack seq;
	TITLE;
	SeqStackInit(&seq);
	SeqStackPush(&seq, 'a');
	SeqStackPush(&seq, 'b');
	SeqStackPush(&seq, 'c');
	SeqStackPush(&seq, 'd');
	SeqStackPush(&seq, 'e');
	SeqStackPush(&seq, 'f');
	 
	PrintStack(&seq, "入栈六个元素");

}

void TestPop() {
	SeqStack seq;
	TITLE;
	SeqStackInit(&seq);
	SeqStackPush(&seq, 'a');
	SeqStackPush(&seq, 'b');
	SeqStackPush(&seq, 'c');
	SeqStackPush(&seq, 'd');
	SeqStackPush(&seq, 'e');
	SeqStackPush(&seq, 'f');

	SeqType e[] = {0};
	SeqStackPop(&seq, e);
	
	printf("\n\n出栈一个元素：%c\n", *e);
}



void TestDestory() {
	SeqStack seq;
	TITLE;
	SeqStackInit(&seq);
	SeqStackPush(&seq, 'a');
	SeqStackPush(&seq, 'b');
	SeqStackPush(&seq, 'c');
	SeqStackPush(&seq, 'd');
	SeqStackPush(&seq, 'e');
	SeqStackPush(&seq, 'f');

	SeqStackDestory(&seq);

	PrintStack(&seq, "销毁栈");
}
int main() {
	TestPush();
	TestPop();
	//TestTop();
	TestDestory();
	system("pause");
	return 0;
}

链式栈

LinkStack.h

#pragma once

#include<stdio.h>
#include<stddef.h>

typedef char StackType;

//创建一个结点的结构体
typedef struct LinkNode{
	StackType data;
	struct LinkNode* _next;
}LinkNode;

//创建栈的结构体
typedef struct LinkStack{

	LinkNode* top;        //栈顶结点
	LinkNode* bottom;     //栈底结点
	size_t size;          //栈的长度

}LinkStack;

//初始化链式栈
void LinkStackInit(LinkStack* link);
//入栈
void LinkStackPush(LinkStack* link, StackType value);
//出栈
StackType LinkStackPop(LinkStack* link);
//销毁
void LinkStackDestory(LinkStack* stack);

LinkStack.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"LinkStack.h"


//创建一个新结点
LinkNode* CreatNewNode(StackType value) {

	LinkNode* p = (LinkNode*)malloc(sizeof(LinkNode));

	p->data = value;
	p->_next = NULL;

	return p;
}

//初始化链式栈
void LinkStackInit(LinkStack* link) {

	if (link == NULL) {
		return;
	}
	link->top = CreatNewNode('0');
	link->bottom = CreatNewNode('0');
	link->top->_next = link->bottom;
	link->size = 0;
}
//判断是否为空栈
int LinkStackEmpty(LinkStack* link) {

	if (link == NULL) {
		return;
	}
	if (link->top->_next == link->bottom && link->size == 0) {
		return 0;
	}
	else{
		return 1;
	}
}
//入栈
void LinkStackPush(LinkStack* link, StackType value) {

	if (link == NULL) {
		return;
	}
	//创建结点
	LinkNode* node = CreatNewNode(value);

	//在链式栈的栈顶结点和栈底结点之前插入一个结点
	LinkNode* next = link->top->_next;

	link->top->_next = node;
	node->_next = next;

	link->size++;
}

//销毁一个结点
void DestoryNode(LinkNode** node) {

	if (node == NULL) {
		return;
	}
	if (*node == NULL) {
		return;
	}
	free(*node);
}

//出栈
StackType LinkStackPop(LinkStack* link) {

	if (link == NULL) {
		return;
	}
	int i = LinkStackEmpty(link);
	if (i = 1) {
		printf("栈为空栈");
		return;
	}
	else {
		//拆除结点
		LinkNode* PopNode = link->top->_next;
		link->top->_next = PopNode->_next;
		link->size--;

		//保存出栈的结点的元素并销毁结点
		StackType n = PopNode->data;
		DestoryNode(&PopNode);
		return n;
	}
}

//销毁
void LinkStackDestory(LinkStack* stack) {

	if (stack == NULL) {
		return;
	}
	//判断是否为空栈
	while (!LinkStackEmpty(stack)) {

		//拆除结点
		LinkNode* Delete = stack->top->_next;
		stack->top->_next = Delete->_next;
		stack->size--;

		//销毁结点
		DestoryNode(&Delete);
	}

}

链式栈的测试代码懒得写了...