数组 模拟实现 栈

//Stack.h

#pragma once



//栈遵循先进后出，后进先出的原则且不能随机插入或者删除元素，只能从栈顶放入或者取出元素


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


//静态栈
//#define N 10
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType a[N];
//	int top;
//}ST;

//动态栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//法1.初始化top=-1;则top先++,再放入元素到top处，此时放完最后一个元素后，top等于最后一个元素的下标，即栈顶的下标，此时的top+1才等于capacity;
	//法2.初始化top=0;则先放元素到top处，再top++;此时放完最后一个元素，也就是放完栈顶的那个元素后，top等于栈顶(最后的那个元素)的下标+1，此时的top=capacity;
	int capacity;
}ST;


ST* CheckCapactiy(ST* ps);//扩容
void StackInit(ST* ps);//这里我们采用法2.
void StackDestroy(ST* ps);//销毁栈
void StackPush(ST* ps, STDataType x);//从栈顶放入元素//根据栈的结构，只能从栈顶放入，所以一般只能尾插(用数组模拟栈的时候，尾插比较方便,以尾部作为栈顶);(用链表模拟栈的时候，头插比较方便
//以头部作为栈顶
void StackPop(ST* ps);//取出栈顶元素
STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);

//Stack.c


#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"

STDataType StackTop(ST* ps)
{
	return ps->a[ps->top-1];
}




ST* CheckCapactiy(ST* ps)
{
	STDataType* tmp = NULL;
	int NewCapacity = ps->capacity == 0 ? 4:2 * (ps->capacity);
	tmp = (STDataType*)realloc(ps->a, sizeof(STDataType)*NewCapacity);
	if (tmp != NULL)
	{
		ps->a = tmp;//!!!注意是给ps->a开辟的空间，而不是给ps
		ps->capacity = NewCapacity;
		printf("扩容成功\n");
		return ps;//!!!记得要把ps return 回去
	}
	else
	{
		printf("扩容失败\n");
		perror("CheckCapacity::realloc");
		exit(-1);
	}
}

void StackPop(ST* ps)
{
	if (ps->top <= 0)
	{
		printf("栈为空\n");
		return;
	}
	else
	{
		ps->top--;
	}
}

void StackPush(ST* ps, STDataType x)
{
	ps=CheckCapactiy(ps);
	ps->a[ps->top] = x;
	ps->top++;
}

void StackDestroy(ST* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

bool StackEmpty(ST* ps)//若为空则返回1；若不为空则返回负的随机值
{
	return ps->capacity == 0;
}

int StackSize(ST* ps)
{
	return ps->top - 1;
}

//test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"

void test()
{
	ST s;
	StackInit(&s);
	//为什么是ST s;之后然后传&s;而不是ST* s;之后直接传s;
	//解析:
	
	//因为要改变的结构体中的数组，如果是直接传结构体指针进去，里面只是会拷贝一份结构体指针，改变里面而外面的不会发生改变
	//为什么带头双向循环链表传的也是结构体指针进去?是因为其的inti初始化是经过返回值返回出来的用指针接受的
	//并且其增删查改都是直接在创建节点的时候赋值的，并不是传节点进去赋值的;

//结构体的数组  和   结构体 链表的增删查改的区别！！！  1.结构体的数组的值需要传结构体的地址进去进行增删查改，而创建的传结构体指针，直接传进去
	//2.链表的增删查改的值是在创建的节点时候就赋予的，不需要传特地传结构体地址进去修改，只需要链接节点就行了。
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	StackPush(&s, 5);
	int size = StackSize(&s);
	printf("栈元素有%d个\n", size);
	int top = StackTop(&s);
	printf("栈顶元素为%d\n", top);
	StackPop(&s);
	StackPop(&s);
	StackPop(&s);
	StackPop(&s);
	StackDestroy(&s);
	StackPop(&s);
	StackPop(&s);
	if (StackEmpty(&s))
	{
		printf("栈已经为空");
	}
	
	
}

int main()
{
	test();
	return 0;
}

测试部分的代码:

 运行图片: