数据结构 完成顺序栈，链式栈的基本操作

顺序栈的初始化 销毁 入栈 出栈 取栈顶元素 

seqstack.h
#pragma once

#include <stdio.h>

#define TITLE printf("\n==========================%s=========================\n",__FUNCTION__);
typedef char SeqStackType;

typedef struct SeqStack
{
	SeqStackType* data;
	size_t size;
	size_t capacity;
}SeqStack;

void SeqStackInit(SeqStack* stack);//初始化
void DestoryStack(SeqStack* stack);//销毁
void SeqStackPush(SeqStack* stack,SeqStackType value);//入栈
void SeqStackPop(SeqStack* stack);//出栈
void SeqStackReSize(SeqStack* stack);//扩容
SeqStackType SeqStackGet(SeqStack* stack);//取栈顶元素

#include "seqstack.h"
#include <stdlib.h>

void SeqStackInit(SeqStack* stack)
{
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	stack->size = 0;
	stack->capacity = 1000;
	stack->data = (SeqStackType*)malloc(stack->capacity * sizeof(SeqStackType));
}

void DestoryStack(SeqStack* stack)
{
	free(stack->data);
	stack->data = NULL;
	stack->size = 0;
	stack->capacity = 0;
}

void SeqStackPrint(SeqStack* stack,const char* msg)
{
	printf("[%s]:\n ",msg);
	if(stack == NULL)
	return;
	size_t i = 0;
	for(;i<stack->size;i++)
	{
		printf("%c ",stack->data[i]);
	}
	printf("\n");
}


void SeqStackReSize(SeqStack* stack)
{
	if(stack == NULL)
	return;
	stack->capacity = stack->capacity * 2 + 1;
	SeqStackType* new_ptr = (SeqStackType*)malloc(stack->capacity * sizeof(SeqStackType));
	//将原来的元素复制到扩容的栈中
	size_t i = 0;
	for(i = 0;i < stack->size;i++)
	{
		new_ptr[i] = stack->data[i];
	}
	free(stack->data);
	stack->data = new_ptr;
	return;
}

void SeqStackPush(SeqStack* stack,SeqStackType value)
{
	if(stack == NULL)
	{
		return;
	}
	if(stack->size >= stack->capacity)
	{
		SeqStackReSize(stack);
	}
	stack->data[stack->size++] = value;
	return;
}


void SeqStackPop(SeqStack* stack)
{
	if(stack == NULL)
	{
		return;
	}
	if(stack->size == 0)
	{
		//空栈
		return;
	}
	if(stack->size == 1)
	{
		DestoryStack(stack);
		return;
	}
	stack->size--;		
}

SeqStackType SeqStackGet(SeqStack* stack)
{
	if(stack == NULL)
	{
		return 0;
	}
	SeqStackType ret = stack->data[stack->size-1];
	return ret;
}

/
//                  以下为测试代码                 //
/

void TestSeqStackInit()
{
	TITLE;
	SeqStack stack;
	SeqStackInit(&stack);
	printf("size expected 0,actual %lu\n",stack.size);
	printf("capacity expected 1000,actual %lu\n",stack.capacity);
}

void TestSeqStackPush()
{
	TITLE;
	SeqStack stack;
	SeqStackInit(&stack);
	SeqStackPush(&stack,'a');
	SeqStackPrint(&stack,"入栈1个元素");
	SeqStackPush(&stack,'b');
	SeqStackPrint(&stack,"入栈1个元素");
	SeqStackPush(&stack,'c');
	SeqStackPrint(&stack,"入栈1个元素");
	SeqStackPush(&stack,'d');
	SeqStackPrint(&stack,"入栈1个元素");
}

void TestSeqStackPop()
{
	TITLE;
	SeqStack stack;
	SeqStackInit(&stack);
	SeqStackPush(&stack,'a');
	SeqStackPush(&stack,'b');
	SeqStackPush(&stack,'c');
	SeqStackPush(&stack,'d');
	SeqStackPrint(&stack,"入栈4个元素");
	SeqStackPop(&stack);
	SeqStackPrint(&stack,"出栈1次");
	SeqStackPop(&stack);
	SeqStackPrint(&stack,"出栈1次");
	SeqStackPop(&stack);
	SeqStackPrint(&stack,"出栈1次");
	SeqStackPop(&stack);
	SeqStackPrint(&stack,"出栈1次");
}

void TestSeqStackGet()
{
	TITLE;
	SeqStack stack;
	SeqStackInit(&stack);
	SeqStackPush(&stack,'a');
	SeqStackPush(&stack,'b');
	SeqStackPush(&stack,'c');
	SeqStackPush(&stack,'d');
	SeqStackPrint(&stack,"入栈4个元素");
	SeqStackType ret = SeqStackGet(&stack);
	printf("取栈顶元素为:\n%c\n",ret);
	SeqStackPop(&stack);
	SeqStackPrint(&stack,"出栈1次");
	ret = SeqStackGet(&stack);
	printf("取栈顶元素为:\n%c\n",ret);
}

int main()
{
	TestSeqStackInit();
	TestSeqStackPush();
	TestSeqStackPop();
	TestSeqStackGet();
	return 0;
}

运行结果：

链式栈的初始化 销毁 入栈 出栈 取栈顶元素

seqliststack.h
#pragma once
#include <stdio.h>
#include <stdlib.h>

#define TITLE printf("\n\n======================%s====================\n",__FUNCTION__);
typedef char ListStackType;
typedef struct ListStack
{
	ListStackType data;
	struct ListStack* next;
}ListStack;

void ListStackInit(ListStack** head);//初始化
void ListStackPrint(ListStack* head,const char* msg);//打印
ListStack* CreateNode(ListStackType value);//创建结点
void DestroyNode(ListStack* node);//销毁结点
void ListStackPush(ListStack** head,ListStackType value);//入栈
void ListStackPop(ListStack** head);//出栈
ListStackType ListStackGet(ListStack* head);//取栈顶元素

#include "seqliststack.h"

void ListStackInit(ListStack** head)
{ 
	if(head == NULL)
	{
		//非法输入
		return;
	}
	*head = NULL;
}

//销毁函数
void ListStackDestroy(ListStack** head)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	ListStack* cur = *head;
	for(;cur != NULL;cur = cur->next)
	{
		free(cur);
	}
	*head = NULL;
}

void ListStackPrint(ListStack* head,const char* msg)
{
	printf("[%s]:\n",msg);
	if(head == NULL)
	{
		return;
	}
	ListStack* cur = head;
	while(cur != NULL)
	{
		printf("%c ",cur->data);
		cur = cur->next;
	}
	printf("\n");
	return;
}

ListStack* CreateNode(ListStackType value)
{
	ListStack* new_node = (ListStack*)malloc(sizeof(ListStack));
	new_node->data = value;
	new_node->next = NULL;
	return new_node;
}

void DestroyNode(ListStack* node)
{
	free(node);
}

//入栈函数,入栈相当于链表的头插
void ListStackPush(ListStack** head,ListStackType value)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	ListStack* newNode = CreateNode(value);
	newNode->next = *head;
	*head = newNode;
	return;
}

//出栈函数,出栈相当于链表的头删
void ListStackPop(ListStack** head)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		//空栈
		return;
	}
	ListStack* to_delete = *head;
	*head = to_delete->next;
	DestroyNode(to_delete);
	return;
}

ListStackType ListStackGet(ListStack* head)
{
	if(head == NULL)
	{
		return;
	}
	ListStack* cur = head;
	return cur->data;
}


///
//                   以下为测试代码                  //
//


void TestListStackInit()
{
	TITLE;
	ListStack* head;
	ListStackInit(&head);
	ListStackPrint(head,"初始化");
}


void TestListStackPush()
{
	TITLE;
	ListStack* head;
	ListStackInit(&head);
	ListStackPush(&head,'a');	
	ListStackPrint(head,"入栈1个元素");
	ListStackPush(&head,'b');	
	ListStackPrint(head,"入栈1个元素");
	ListStackPush(&head,'c');	
	ListStackPrint(head,"入栈1个元素");
	ListStackPush(&head,'d');	
	ListStackPrint(head,"入栈1个元素");
}

void TestListStackPop()
{
	TITLE;
	ListStack* head;
	ListStackInit(&head);
	ListStackPush(&head,'a');	
	ListStackPush(&head,'b');	
	ListStackPush(&head,'c');	
	ListStackPush(&head,'d');	
	ListStackPrint(head,"入栈4个元素");
	ListStackPop(&head);
	ListStackPrint(head,"出栈1个元素");
	ListStackPop(&head);
	ListStackPop(&head);
	ListStackPrint(head,"出栈2个元素");
	ListStackPop(&head);
	ListStackPrint(head,"出栈1个元素");
}

void TestListStackGet()
{
	TITLE;
	ListStack* head;
	ListStackInit(&head);
	ListStackType ret = ListStackGet(head);	
	ListStackPrint(head,"空栈");
	printf("取栈顶元素为： %c\n\n",ret);
	ListStackPush(&head,'a');	
	ListStackPrint(head,"入栈1个元素");
	ret = ListStackGet(head);	
	printf("取栈顶元素为： %c\n\n",ret);
	ListStackPush(&head,'b');	
	ListStackPush(&head,'c');	
	ListStackPush(&head,'d');	
	ListStackPrint(head,"再入栈3个元素");
	ret = ListStackGet(head);	
	printf("取栈顶元素为： %c\n",ret);
}

int main()
{
	TestListStackInit();
	TestListStackPush();
	TestListStackPop();
	TestListStackGet();
	return 0;
}

运行结果：