数据结构-栈的链式存储（6）

测试框架

#include"LinkStack.h"      
#include<stdio.h>      
#include<stdlib.h>      
#include<string.h>   

void main()
{
	int i = 0;
	int a[10];
	LinkStack* stack = NULL;
	stack = Stack_Create();
	if (stack==NULL)
	{
		return;
	}
	//添加元素
	for ( i = 0; i < 5; i++)
	{
		a[i] =i+ 1;
		Stack_Push(stack,&a[i]);
	}
	//获取栈的基本属性
	printf("len:%d",Stack_Size(stack));
	printf("top:%d",*((int*)Stack_Top(stack)));
	//删除栈元素
	while (Stack_Size(stack)>0)
	{
		int tmp = *((int*)Stack_Pop(stack));
			printf("tmp :%d",tmp);
	}

	Stack_Destory(stack);
	printf("wwww");
	system("pause");
}

头文件

"LinkStack.h"栈的和"linklist.h"线性表的链式存储

"LinkStack.h"

#pragma once  
#ifdef _MYLIST_H_      
#define _MYLIST_H_      
#endif // _MYSEQLIST_H_      

typedef void LinkStack;


/*创建列表*/
LinkStack * Stack_Create();
/*释放列表*/
void Stack_Destory(LinkStack* stack);
/*清空列表 回到初始状态*/
void Stack_Clear(LinkStack* stack);
//入栈  
int Stack_Push(LinkStack* stack, void* item);
//出栈，即删除栈顶元素  
void* Stack_Pop(LinkStack* stack);
//获取栈顶元素  
void* Stack_Top(LinkStack* stack);
/*获取链表的长度*/
int Stack_Size(LinkStack* stack);

"linklist.h"

#pragma once
#ifdef _MYLIST_H_
#define _MYLIST_H_
#endif // _MYSEQLIST_H_

typedef void Linklist;
typedef struct LinkListNode
{
	struct LinkListNode* next;
};
/*创建列表*/
Linklist * List_Create();
/*释放列表*/
void List_Destory(Linklist* list);
/*清空列表 回到初始状态*/
void List_Clear(Linklist* list);
/*获取链表的长度*/
int List_Length(Linklist* list);
/*获取指定位置的链表的元素数据*/
LinkListNode* List_Get(Linklist* list, int pos);
/*插入元素数据*/
int List_Inster(Linklist* list, LinkListNode* node, int pos);
/*元素数据删除*/
LinkListNode* List_Delete(Linklist* list, int pos);

"LinkStack.cpp"

#include"LinkStack.h"      
#include<stdio.h>      
#include<stdlib.h>      
#include<string.h>    
#include"linklist.h"


typedef struct Teacher
{
	LinkListNode node;
	void* item;
};
typedef struct TLinkStackNode
{
	LinkListNode node;
	void* item;
};


/*创建列表*/
LinkStack * Stack_Create()
{

	return List_Create();
}
/*释放列表*/
void Stack_Destory(LinkStack* stack)
{
	if (stack == NULL)
	{
		return;
	}
	Stack_Clear(stack);
	List_Destory(stack);
	return ;
}
/*清空列表 回到初始状态 相当于清空一个线性表*/
//清空栈的时候，涉及到栈元素生命周期的管理
//所有入栈的结点都是malloc
//若要清空栈，把栈中元素弹出，并且释放结点内存
void Stack_Clear(LinkStack* stack)
{
	if (stack==NULL)
	{
		return;
	}
	while (Stack_Size(stack)>0)
	{
		Stack_Pop(stack);//在这个函数中释放结点的内存
	}

	return ;
}
//入栈  
int Stack_Push(LinkStack* stack, void* item)
{
	TLinkStackNode* tmp = NULL;
	int ret = 0;
	tmp = (TLinkStackNode*)malloc(sizeof(TLinkStackNode));
	if (tmp==NULL)
	{
		return -1;
	}
	memset(tmp,0,sizeof(TLinkStackNode));
	tmp->item = item;
	ret = List_Inster(stack,(LinkListNode*)tmp,0);
	if (ret!=0)
	{
		if (tmp!=NULL)
		{
			free(tmp);
		}
		return ret;
	}

	return ret;
}
//出栈，即删除栈顶元素  从栈中弹出元素，从线性表的头部删除元素
//把线性表的业务结点 转化成 栈的业务结点
void* Stack_Pop(LinkStack* stack)
{
	void* item = NULL;
	TLinkStackNode * tmp = NULL;
	tmp = (TLinkStackNode*)List_Delete(stack, 0);
	if (tmp == NULL)
	{
		return NULL;
	}
	item = tmp->item;
	//因为List_Insert的时候，分配了内存，所以List_Delete释放内存
	free(tmp);
	return item;
}
//获取栈顶元素   相当于获取线性表的0号位置
void* Stack_Top(LinkStack* stack)
{
	TLinkStackNode* tmp = NULL;

	tmp = (TLinkStackNode*)List_Get(stack,0);
	if (tmp==NULL)
	{
		return NULL;
	}
	return tmp->item;
}
/*获取链表的长度  相当于求线性表的长度*/
int Stack_Size(LinkStack* stack)
{
	return List_Length(stack);
}

"linklist..cpp"

#include"linklist.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct TLinkList
{
     LinkListNode header;
	int lenght;
};
/*创建列表*/
Linklist * List_Create()
{
	TLinkList* ret = NULL;
	ret = (TLinkList*)malloc(sizeof(TLinkList));
	memset(ret,0,sizeof(TLinkList));
	ret->lenght = 0;
	ret->header.next = NULL;
	return ret;
}
/*释放列表*/
void List_Destory(Linklist* list)
{
	if (list==NULL)
	{
		free(list);
		list = NULL;
	}
	return ;
}
/*清空列表 回到初始状态*/
void List_Clear(Linklist* list)
{
	TLinkList *tlist = NULL;
	if (list==NULL)
	{
		return;
	}
	tlist = (TLinkList*)list;
	tlist->lenght = 0;
	tlist->header.next = NULL;
	return ;
}
/*获取链表的长度*/
int List_Length(Linklist* list)
{
	TLinkList* tlist = NULL;
	if (list == NULL)
	{
		return 0;
	}
	tlist = (TLinkList*)list;

	return tlist->lenght;
}
/*获取指定位置的链表的元素数据*/
LinkListNode* List_Get(Linklist* list, int pos)
{
	int i = 0;
	if (list==NULL||pos<0)
	{
		return NULL;
	}
	LinkListNode* current = NULL;
	TLinkList* tlist = NULL;
	tlist = (TLinkList*)list;
	current = &(tlist->header);
	//让辅助指针指向链表的头部
	for ( i = 0; i < pos&&(current->next!=NULL); i++)
	{
		current = current->next;
	}
	return current->next;
}
/*插入元素数据*/
int List_Inster(Linklist* list, LinkListNode* node, int pos)
{
	if (list == NULL || pos<0||node==NULL)
	{
		return 0;
	}
	int i = 0, ret = 0;
	TLinkList* tlist = NULL;
	tlist = (TLinkList*)list;
	LinkListNode* current = NULL;
	current = &(tlist->header);
	for ( i = 0; i < pos&&(current->next!=NULL); i++)
	{
		current = current->next;
	}
	node->next = current->next;
	current->next = node;
	tlist->lenght++;
	return 0;
}
/*元素数据删除*/
LinkListNode* List_Delete(Linklist* list, int pos)
{
	int i = 0;
	if (list == NULL || pos<0 )
	{
		return 0;
	}
	TLinkList* tlist = NULL;
	LinkListNode* current = NULL;
	tlist = (TLinkList*)list;
	current = &(tlist->header);
	LinkListNode* ret = NULL;
	for ( i = 0; i <pos&&(current->next!=NULL); i++)
	{
		current = current->next;
	}
	ret = current->next;
	current->next = ret->next;
	tlist->lenght--;
	return ret;
}