数据结构-栈的顺序存储（5）

测试框架

#include"Stack.h"    
#include<stdio.h>    
#include<stdlib.h>    
#include<string.h>  
#include"SeqList.h"

///*创建列表*/
//SeqStack * List_Create(int capacity);
///*释放列表*/
//void List_Destory(SeqStack* stack);
///*清空列表 回到初始状态*/
//void List_Clear(SeqStack* stack);
///*获取链表的长度*/
//int Stack_Push(SeqStack* stack, void* item);
//
//void* Stack_Pop(SeqStack* stack);
//void* Stack_Top(SeqStack* stack);
//int Stack_Size(SeqStack* stack);
//int Stack_Capacity(SeqStack* stack);
void main()
{
	int i = 0;
	int a[10];

	SeqStack *  stack= List_Create(10);

	if (stack == NULL)
	{
		return;
	}
	//压栈

	for ( i = 0; i < 5; i++)
	{
		a[i] = i + 1;
		Stack_Push(stack,&a[i]);
	}
	printf("Capacity:%d\n",Stack_Capacity(stack));

	printf("Stack_Lenght:%d\n", Stack_Size(stack));
	printf("Top:%d\n", *((int*)(Stack_Top(stack))));
	while (Stack_Size(stack)>0)
	{
		int tmp = *((int*)(Stack_Pop(stack)));
		printf("tmp:%d\n",tmp);
	}
	printf("\n");
	system("pause");
}

两个头文件 SeqList.h  和 Stack.h

Stack.h

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

typedef void SeqStack;

/*创建列表*/
SeqStack * List_Create(int capacity);
/*释放列表*/
void List_Destory(SeqStack* stack);
/*清空列表 回到初始状态*/
void List_Clear(SeqStack* stack);
//入栈
int Stack_Push(SeqStack* stack, void* item);
//出栈，即删除栈顶元素
void* Stack_Pop(SeqStack* stack);
//获取栈顶元素
void* Stack_Top(SeqStack* stack);
/*获取链表的长度*/
int Stack_Size(SeqStack* stack);
//栈的容量
int Stack_Capacity(SeqStack* stack);

SeqList.h

#pragma once
#ifdef _MYSEQLIST_H_
#define _MYSEQLIST_H_
#endif // _MYSEQLIST_H_
//线性链表的顺序存储
//void指针表示未知类型的指针，可以将任意类型的指针直接赋值给void指针，好比是C#、Java中的object引用，可以把任意 类型的对象赋值给它。但把void类型赋值给特定类型的指针时，就需要进行强制转换，因为C++为类型语言，尽可能保证类型安全，如果使用了强制类型转 换，编译器就认为程序员知道他（她）在干什么，程序也应该负起这样做的责任。
typedef void Seqlist;
typedef void SeqListNode;

Seqlist * List_Create1(int capacity);
void List_Destory1(Seqlist* list);
void List_Clear1(Seqlist* list);
int List_Length1(Seqlist* list);
int List_Capacity1(Seqlist* list);
SeqListNode* List_Get1(Seqlist* list, int pos);
int List_Inster1(Seqlist* list, SeqListNode* node, int pos);
SeqListNode* List_Delete1(Seqlist* list,int pos);

头文件的实现

#include"SeqList.h"
#include<stdio.h>
#include<stdlib.h>
using namespace std;
struct  TSeqList
{
	int length;
	int capacity;
	unsigned int **node;
};
/*创建链表并为链表分配空间*/
Seqlist* List_Create1(int capacity)
{
	TSeqList* tmp = NULL;
	tmp = (TSeqList*)malloc(sizeof(TSeqList));
	if (tmp==NULL)
	{
		return NULL;
	}
	tmp->node =(unsigned int**)malloc(sizeof(unsigned int*)*capacity);
	tmp->length = 0;
	tmp->capacity = capacity;
	return tmp;
}
/*销毁链表并释放链表的内存空间*/
void List_Destory1(Seqlist* list)
{
	TSeqList* tlist = NULL;
	if (list==NULL)
	{
		printf("List_Destory() err:");
		return;
	}
	tlist = (TSeqList*)list;
	if (tlist->node!=NULL)
	{
		free(tlist->node);
	}
	if (tlist->length!=0)
	{
		free(tlist);
	}
	return ;
}
/*清空链表，回到初始链表的状态*/
void List_Clear1(Seqlist* list)
{
	TSeqList* tlist = NULL;
	if (list==NULL)
	{
		printf("List_Clear() err:");
		return;
	}
	tlist = (TSeqList*)list;
	tlist->length = 0;
	return ;
}
/*链表长度大小*/
int List_Length1(Seqlist* list)
{
	TSeqList* tlist = NULL;
	if (list==NULL)
	{
		printf("List_Length() err:");
		return -1;
	}
	tlist = (TSeqList*)list;
	return tlist->length;
}
/*链表大小获取*/
int List_Capacity1(Seqlist* list)
{
	TSeqList* tlist = NULL;
	if (list==NULL)
	{
		printf("List_Capacity() err:");
		return -1;
	}
	tlist = (TSeqList*)list;

	return tlist->capacity;
}
/*元素获取*/
SeqListNode* List_Get1(Seqlist* list, int pos)
{
	TSeqList* tlist = NULL;
	if (list == NULL||pos<0)
	{
		printf("List_Get() err:");
		return NULL;
	}
	tlist = (TSeqList*)list;
	
	return tlist->node[pos];
}
/*元素插入*/
int List_Inster1(Seqlist* list, SeqListNode* node, int pos)
{
	TSeqList* tlist = NULL;
	if (list == NULL || pos<0||node==NULL)
	{
		printf("List_Inster() err:");
		return -1;
	}
	int i = 0;
	SeqListNode* ret = NULL;
	tlist = (TSeqList*)list;
	//判断是不是链表中已经满了
	if (tlist->length==tlist->capacity)
	{
		printf("List_Inster() err: yiman");
		return -2;
	}
	//容错修正，比如 6歌长度 容量为20，用户在10位置插入，则进行容错
	if (pos>=tlist->length)
	{
		pos = tlist->length;
	}
	//数据元素后移  头插法
	for ( i = tlist->length; i > pos; i--)
	{
		tlist->node[i] = tlist->node[i-1];
	}
    //插入元素
	tlist->node[i] = (unsigned int *)node;
	tlist->length++;
	return 0;
}
/*元素删除*/
SeqListNode* List_Delete1(Seqlist* list, int pos)
{
	TSeqList* tlist = NULL;
	if (list==NULL||pos<0)
	{
		printf("List_Delete() err: ");
		return NULL;
	}
	tlist = (TSeqList*)list;
	SeqListNode* ret = NULL;
	ret = tlist->node[pos];
	int i = 0;
	for ( i =pos+1; i <tlist->length; i++)
	{
		tlist->node[i - 1] = tlist->node[i];
	}
	tlist->length--;
	return ret;
}

Stack.cpp

#include"Stack.h"    
#include<stdio.h>    
#include<stdlib.h>    
#include<string.h>  
#include"SeqList.h"

/*创建列表   c创建栈相当于创建线性表*/
SeqStack * List_Create(int capacity)
{
	return 	List_Create1(capacity);
}
/*释放列表  销毁栈相当于销毁线性表*/
void List_Destory(SeqStack* stack) 
{
	return List_Destory1(stack);
}
/*清空列表 回到初始状态 请空栈相当于清空线性表*/
void List_Clear(SeqStack* stack)
{
	return List_Clear1(stack);
}
/*向栈中压入元素，相当于向链表的尾部插入元素*/
int Stack_Push(SeqStack* stack, void* item)
{

	return	List_Inster1(stack, item, List_Length1(stack));//尾部插入，尾插法
}
//从栈中弹出元素，相当于从链表的尾部拿出元素
void* Stack_Pop(SeqStack* stack)
{
	return List_Delete1(stack,List_Length1(stack)-1);

}
//获取栈顶元素，相当于获取链表的尾部元素
void* Stack_Top(SeqStack* stack)
{
	return List_Get1(stack,List_Length1(stack)-1);
}
//获取栈的大小，相当于获取链表的实际长度
int Stack_Size(SeqStack* stack)
{
	return List_Length1(stack);
}
//获取栈的容量 相当于获取线性表的容量
int Stack_Capacity(SeqStack* stack)
{
	return List_Capacity1(stack);
}