【数据结构---16】C语言实现一个动态栈

Stack.h

#pragma once

typedef int Sdatatype;

typedef struct Stack
{
	 Sdatatype* _array;
	 int top;
	 int capacity;
}Stack;

void StackInit(Stack* ps);

void StackDestroy(Stack* ps);

void StackPush(Stack*ps, Sdatatype data);

void StackPop(Stack* ps);

int StackTop(Stack* ps);

int StackEmpty(Stack* ps);

int StackCapacity(Stack* ps);

void TestStack();

Stack.c

#include "stack.h"
#include<stdio.h>
#include<stdlib.h>
#include <assert.h>
#include <malloc.h>

初始化操作:

void StackInit(Stack* ps)
{
	 assert(ps);
	 int capacity = 5;
	 ps->_array = (Sdatatype*)malloc(capacity*sizeof(Sdatatype));
	 if (ps->_array == NULL)
	 {
		  assert(0);
	 }
	 ps->capacity = capacity;
	 ps->top = 0;
}

销毁栈:

void StackDestroy(Stack* ps)
{
	 assert(ps);
	 free(ps->_array);
	 ps->_array = NULL;
	 ps->capacity = 0;
	 ps->top = 0;
}

压栈:

void StackPush(Stack* ps, Sdatatype data)
{
	 assert(ps);
	 if (ps->top == ps->capacity)
	 {
		  int newcapacity = 2 * ps->capacity;
		  int* a2 = (Sdatatype*)malloc(sizeof(Stack)*newcapacity);
		  for (int i = 0; i < ps->top; ++i)
		  {
			   a2[i] = ps->_array[i];
		  }
		  ps->_array = a2;
		  ps->_array[ps->top] = data;
		  ps->top++;
		  ps->capacity = newcapacity;
	 }
	 else
	 {
		  ps->_array[ps->top] = data;
		  ps->top++;
	 }
}

出栈:

void StackPop(Stack* ps)
{
	 assert(ps);
	 if (ps->top == 0)
	 {
		  return;
	 }
	 ps->top--;
}

获取栈顶元素:

int StackTop(Stack* ps)
{
	 assert(ps);
	 if (ps->top == 0)
	 {
		  return -1;
	 }
	 return ps->_array[ps->top-1];
}

判断是否为空栈:

int StackEmpty(Stack* ps)
{
	 assert(ps);
	 if (ps->top == 0)
	 {
		  return -1;
	 }
	 else
	 {
		  return 1;
	 }
}

获取栈的容量:

int StackCapacity(Stack* ps)
{
	 assert(ps);
	 return ps->capacity;
}

测试栈的实现:

void TestStack()
{
	 Stack s;
	 StackInit(&s);
	 
	//将数据压入栈
	 StackPush(&s, 1);
	 StackPush(&s, 2);
	 StackPush(&s, 3);
	 
	//获取栈顶数据
	 StackTop(&s);
	 printf("Top=%d\n", StackTop(&s));
	 
	//获取栈的容量
	 StackCapacity(&s);
	 printf("Capacity=%d\n", StackCapacity(&s));
	 
	//查看扩容功能是否实现
	 StackPush(&s, 4);
	 StackPush(&s, 5);
	 StackPush(&s, 7);
	 
	//获取栈顶元素
	 StackTop(&s);
	 printf("Top=%d\n", StackTop(&s));
	 
	//获取扩容之后栈的容量
	 StackCapacity(&s);
	 printf("Capacity=%d\n", StackCapacity(&s));
	 
	//出栈
	 StackPop(&s);
	 StackPop(&s);
	 StackPop(&s);
	 
	//获取栈顶元素
	 StackTop(&s);
	 printf("Top=%d\n", StackTop(&s));
	 
	//销毁栈
	 StackDestroy(&s);
}

主函数:

int main()
{
	 TestStack();
	 system("pause");
	 return 0;
}

代码运行测试图: