2024.12.03（栈和队列）

作业：

1> 将顺序栈、循环顺序队列、链式队列 数据结构重新自己实现一遍

2> 思维导图

顺序栈代码实现

声明文件  fun.h

#ifndef FUN_H
#define FUN_H
#include <myhead.h>

//数据元素
typedef char datatype;

#define SIZE 8     //栈的初始大小

//定义栈的类型
typedef struct
{
	datatype *data; 	//存储栈的容器，用于指向堆区空间
	int top; 			//记录栈元素下标
	int size; 			//记录当前栈的最大容量
}Seqstack,*seqstackptr;

//创建顺序栈
seqstackptr stack_create();
//判空
int stack_empty(seqstackptr S);
//判满
int stack_full(seqstackptr S);
//入栈
int stack_push(seqstackptr S,datatype e);
//遍历
int stack_show(seqstackptr S);
//出栈
int stack_pop(seqstackptr S);
//销毁栈
void stack_destroy(seqstackptr S);
#endif





功能函数 fun.c
#include "fun.h"
//创建顺序栈
seqstackptr stack_create()
{
	//在堆区申请一个顺序栈的空间
	seqstackptr S = (seqstackptr)malloc(sizeof(Seqstack));
	if(NULL == S)
	{
		printf("创建栈失败\n");
		return NULL;
	}
	//此时，栈的空间就申请好了，但是，没有存储栈的连续内存
	S->data = (datatype*)malloc(sizeof(datatype)*SIZE);
	if(S->data == NULL)
	{
		printf("创建顺序栈失败\n");
		free(S);
		return NULL;
	}

	//此时顺序栈申请成功，并且有了存储顺序栈的容器
	//对顺序栈栈顶进行初始化
	S->top = -1;
	S->size = SIZE; 		//当前最大容量

	printf("顺序栈创建成功\n");
	return S;
}

//判空
int stack_empty(seqstackptr S)
{
	if(NULL == S||S->data == NULL)
	{
		printf("所给栈不合法\n");
		return -1;
	}

	//判断是否为空
	return S->top == -1;
}

//判满
int stack_full(seqstackptr S)
{
	if(NULL == S||S->data == NULL)
	{
		printf("所给栈不合法\n");
		return -1;
	}
	return S->top == S->size-1;
}

//二倍扩容函数
static int stack_expend(seqstackptr S)
{
	//判断逻辑，可以不用判断，是用于某个函数的子函数
	if(NULL == S)
	{
		printf("所给栈不合法\n");
		return -1;
	}

	//扩容逻辑
	datatype *temp = malloc(sizeof(datatype)*S->size*2);
	if(NULL == temp)
	{
		printf("扩容失败\n");
		return -1;
	}

	//内存拷贝
	memcpy(temp,S->data,sizeof(datatype)*S->size);

	//释放原内存
	free(S->data);
	//将指针指向新的内存
	S->data = temp;
	S->size *= 2;  		//最大容量乘以2

	printf("扩容成功\n");
	return 0;
}

//入栈
int stack_push(seqstackptr S,datatype e)
{
	//判断逻辑
	if(NULL==S)
	{
		printf("所给栈不合法\n");
		return -1;
	}

	if(stack_full(S))
	{
		//开始二倍扩容
		stack_expend(S);
	}
	//入栈逻辑
	S->top++;
	S->data[S->top] = e;

	printf("入栈成功\n");
	return 0;
}


//遍历
int stack_show(seqstackptr S)
{
	if(NULL==S||stack_empty(S))
	{
		printf("遍历失败\n");
		return -1;
	}

	//遍历逻辑
	printf("当前栈从栈顶到栈底元素分别是：");
	for(int i=S->top;i>=0;i--)
		{
			printf("%d\t",S->data[i]);
		}
	putchar(10);
}

//出栈
int stack_pop(seqstackptr S)
{
	if(NULL == S||stack_empty(S))
	{
		printf("出栈失败\n");
		return -1;
	}
	//出栈 先进后出
	datatype e = S->data[S->top];
	S->top--;

	printf("%d出栈成功\n",e);
	return 0;
}

//销毁栈
void stack_destroy(seqstackptr S)
{
	//判断逻辑
	if(NULL == S)
	{
		return;
	}
	//如果容器空间为空
	if(NULL == S->data)
	{
		free(S);
		S = NULL;
		return ;
	}
	//先释放容器空间
	free(S->data);
	//释放顺序栈的空间
	free(S);
	S = NULL; //这是栈区指针，其实没有必要制空
	printf("释放成功\n");
}




//主函数
#include "fun.h"
#include <myhead.h>

int main(int argc, const char *argv[])
{
    //调用创建栈函数
    seqstackptr S = stack_create();
    if(NULL==S)
    {
        return -1;
    }

    //调用入栈函数
    stack_push(S, 3);
    stack_push(S, 7);
    stack_push(S, 2);
    stack_push(S, 1);
    stack_push(S, 4);
    stack_push(S, 6);
    stack_push(S, 9);
    stack_push(S, 8);
    stack_push(S, 5);
    stack_push(S, 5);
    stack_push(S, 5);
    stack_push(S, 5);
    stack_push(S, 5);
    stack_push(S, 5);
    stack_push(S, 5);
    stack_push(S, 5);
    stack_push(S, 5);

    printf("%d\n", S->size);

    //调用遍历函数
    stack_show(S);

    //调用出栈函数
    stack_pop(S);
    stack_pop(S);
    stack_pop(S);

    stack_show(S);

    //销毁顺序栈
    stack_destroy(S);
    S = NULL;
    stack_show(S);	
	return 0;
}

思维导图