数据结构四：栈的两种形式LinkStack和SeqStack用线性表的实现方式,以及SeqQueue和LinkQueue的实现

      之前写过两篇对于SeqList和LinkList的底层封装库，在阅读这篇博文前还是仔细看一下之前的底层库封装实现，因为栈的结构是一种特殊的线性表，本文探讨栈的实现由之前的线型库实现的，实践是检验真理的唯一标准，请对我的线性链表库函数有足够的信心吧！Just Like!Just Do IT !!!

     

      SeqStack的实现方式：

     

#ifndef MY_SeqStack_H
#define MY_SeqStack_H

typedef void SeqStack;
//创建顺序堆栈
SeqStack* SeqStack_Create(int capacity);

//堆栈的销毁
void SeqStack_Deatroy(SeqStack* seqstack);

//堆栈的清除
void SeqStack_Clear(SeqStack* seqstack);

//压栈操作
void SeqStack_Push(SeqStack* seqstack,void* item);

//出栈操作
void* SeqStack_Pop(SeqStack* seqstack);

//获取栈顶的元素
void* SeqStack_Top(SeqStack* seqstack);

//获取栈的长度
int SeqStack_Size(SeqStack* seqstack);

//获取栈的容量 
int SeqStack_Capacity(SeqStack* seqstack);

#endif

SeqStack的实现文件：

#include "stdlib.h"
#include "stdio.h"
#include "seqstack.h"
#include "myseqlist.h"

//创建顺序堆栈
SeqStack* SeqStack_Create(int capacity)
{
	return SeqList_Create(capacity);
}

//堆栈的销毁
void SeqStack_Deatroy(SeqStack* seqstack)
{
	SeqList_Destroy((SeqList*)seqstack);
}

//堆栈的长度
int SeqStack_Length(SeqStack* seqstack)
{
	return SeqList_Length((SeqList*)seqstack);
}

//堆栈的清除
void SeqStack_Clear(SeqStack* seqstack)
{
	SeqList_Clear((SeqList*)seqstack);
}

//压栈操作
void SeqStack_Push(SeqStack* seqstack, void* item)
{
	//在线性表的最后一个位置插入元素节点  尾插法 
	SeqList_Insert((SeqList*)seqstack, (SeqListNode*)item, SeqStack_Length(seqstack));

}

//出栈操作
void* SeqStack_Pop(SeqStack* seqstack)
{
	//删除最后一个元素 
	return SeqList_Delete((SeqList*)seqstack, SeqStack_Length(seqstack)-1);
}

//获取栈顶的元素
void* SeqStack_Top(SeqStack* seqstack)
{
	//获得最后一个元素
	return SeqList_Get((SeqList*)seqstack, SeqStack_Length(seqstack) - 1);
}

//获取栈的长度
int SeqStack_Size(SeqStack* seqstack)
{
	return  SeqList_Length((SeqList*)seqstack);
}

//获取栈的容量 
int SeqStack_Capacity(SeqStack* seqstack)
{
	return SeqList_Capacity((SeqList*)seqstack);
}

这是调用之前的线性顺序存储库函数，是不是很爽啊！！！！！！！

 模拟栈的业务流程：

#include "stdlib.h"
#include "stdio.h"
#include "seqstack.h"
#include "myseqlist.h"

typedef struct _tag_Teacher
{
	int age;
	char* name;
}Teacher;
void TestDemo1()
{
	//模仿顺序栈的业务流程
	SeqStack* mseqstack;
	Teacher* tmp;
	Teacher t1, t2, t3, t4, t5;
	int capacity = 10;
	t1.age = 11;
	t2.age = 22;
	t3.age = 33;
	t4.age = 44;
	t5.age = 55;
	t1.name = "shao11";
	t2.name= "shao22";
	t3.name = "shao33";
	t4.name = "shao44";
	t5.name = "shao55";
	mseqstack = SeqStack_Create(capacity);
	SeqStack_Push(mseqstack, (void*)&t1);
	SeqStack_Push(mseqstack, (void*)&t2);
	SeqStack_Push(mseqstack, (void*)&t3);
	SeqStack_Push(mseqstack, (void*)&t4);
	SeqStack_Push(mseqstack, (void*)&t5);
	printf("seqstack size:%d;capacity:%d\n", SeqStack_Size(mseqstack), SeqStack_Capacity(mseqstack));
	tmp = (Teacher*)SeqStack_Top(mseqstack);
	printf("\ntop first teacher age:%d:name:%s\n", tmp->age, tmp->name);
	while (SeqStack_Size(mseqstack) > 0)
	{
		tmp = (Teacher*)SeqStack_Pop(mseqstack);
		printf("\npop teacher age:%d;name:%s\n", tmp->age, tmp->name);
	}

	SeqStack_Deatroy(mseqstack);
}

void maintest1()
{
	TestDemo1();
	printf("邵忠棋");
	system("pause");
}

下面是LinkStack的头文件

#ifndef  __MY_SEQLIST_H__ 
#define __MY_SEQLIST_H__

typedef void LinkStack;
LinkStack* LinkStack_Create();
void LinkStack_Clear(LinkStack* linkstack);
void LinkStack_Destroy(LinkStack* linkstack);
int LinkStack_Size(LinkStack* linkstack);
void* LinkStack_Push(LinkStack* linkstack,void* stacknode);
void* LinkStack_Top(LinkStack* linkstack);
void* LinkStack_Pop(LinkStack* linkstack);


#endif  //__MY_SEQLIST_H__

LinkStak的实现：

#include "stdlib.h"
#include "stdio.h"
#include "linkstack.h"
#include "linklist.h"

typedef struct _tag_LinkStackNode
{
	LinkListNode node;
    void* item;
}MyLInkStackNode;

LinkStack* LinkStack_Create()
{
	return LinkList_Create();

}
void LinkStack_Clear(LinkStack* linkstack)
{
	LinkList_Clear(linkstack);
}
void LinkStack_Destroy(LinkStack* linkstack)
{
	LinkList_Destroy(linkstack);
}
int LinkStack_Size(LinkStack* linkstack)
{
	return LinkList_Length(linkstack);
}
void* LinkStack_Push(LinkStack* linkstack, void* stacknode)
{
	//采用头插法   因为底层采用的是linklist库，插入的时候需要有一个LinkListNode的占位指针
	//需要malloc  linkstackNode  否则会被回收
	MyLInkStackNode* mystacknode = (MyLInkStackNode*)malloc(sizeof(MyLInkStackNode));
	mystacknode->item = stacknode;
	LinkList_Insert((LinkList*)linkstack, (LinkListNode*)mystacknode, 0);
	return stacknode;
}
void* LinkStack_Top(LinkStack* linkstack)
{
	MyLInkStackNode* mystacknode = (MyLInkStackNode*)LinkList_Get((LinkList*)linkstack, 0);
	return mystacknode->item;
}
void* LinkStack_Pop(LinkStack* linkstack)
{
	MyLInkStackNode* mystacknode = (MyLInkStackNode*)LinkList_Delete((LinkList*)linkstack, 0);
	return mystacknode->item;
}

是不是很爽啊~~~~~~~~~~~~~

LinkStack的业务流：

下面是队列queue的实现 

SeqQueue实现：

#ifndef _MY_SEQQUEUE_H_
#define _MY_SEQQUEUE_H_


typedef void SeqQueue;

SeqQueue* SeqQueue_Create(int capacity);
void SeqQueue_Clear(SeqQueue* seqqueue);
void SeqQueue_Destroy(SeqQueue* seqqueue);
//入队列
int SeqQueue_Append(SeqQueue* seqqueue,void* item);
//出队列
void* SeqQueue_Retrive(SeqQueue* seqqueue);
//首元素
void* SeqQueue_Header(SeqQueue* seqqueue);
int SeqQueue_Length(SeqQueue* seqqueue);
int SeqQueue_Capacity(SeqQueue* seqqueue);


#endif //_MY_SEQQUEUE_H_

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "SeqQueue.h"
#include "myseqlist.h"

SeqQueue* SeqQueue_Create(int capacity)
{
	return SeqList_Create(capacity);
}
void SeqQueue_Clear(SeqQueue* seqqueue)
{
	SeqList_Clear(seqqueue);
}
void SeqQueue_Destroy(SeqQueue* seqqueue)
{
	SeqList_Destroy(seqqueue);
}
//入队列
int SeqQueue_Append(SeqQueue* seqqueue, void* item)
{
	return SeqList_Insert(seqqueue, item, SeqList_Length(seqqueue));
}
//出队列
void* SeqQueue_Retrive(SeqQueue* seqqueue)
{
	return SeqList_Delete(seqqueue, 0);
}
//首元素
void* SeqQueue_Header(SeqQueue* seqqueue)
{
	return SeqList_Get(seqqueue, 0);
}
int SeqQueue_Length(SeqQueue* seqqueue)
{
	return SeqList_Length(seqqueue);
}
int SeqQueue_Capacity(SeqQueue* seqqueue)
{
	return SeqList_Capacity(seqqueue);
}

LinkQueue实现

#ifndef _MY_LinkQueue_H_
#define _MY_LinkQueue_H_

typedef void LinkQueue;
LinkQueue* LinkQueue_Create();
void LinkQueue_Clear(LinkQueue* linkqueue);
void LinkQueue_Destroy(LinkQueue* linkqueue);
void LinkQueue_Append(LinkQueue* linkqueue,void* item);
void* LinkQueue_Retrive(LinkQueue* linkqueue);
int LinkQueue_Length(LinkQueue* linkqueue);
void* Linkqueue_Header(LinkQueue* linkqueue);


#endif //_MY_SEQQUEUE_H_

#include "stdio.h"
#include "stdlib.h"
#include "LinkQueue.h"
#include "linklist.h"

typedef struct _tag_LinkQueueNode
{
	LinkListNode node;
	void* item;
}LinkQueueNode;


LinkQueue* LinkQueue_Create()
{
	return LinkList_Create();
}
void LinkQueue_Clear(LinkQueue* linkqueue)
{
	LinkList_Clear(linkqueue);
}
void LinkQueue_Destroy(LinkQueue* linkqueue)
{
	LinkList_Destroy(linkqueue);
}
void LinkQueue_Append(LinkQueue* linkqueue, void* itemitem)
{
	//先创建一个对象 然后进行插入操作 
	LinkQueueNode* mnode = malloc(sizeof(LinkQueueNode));
	mnode->item = itemitem;
	LinkList_Insert(linkqueue, (LinkListNode*)&mnode->node, LinkList_Length(linkqueue));
}
void* LinkQueue_Retrive(LinkQueue* linkqueue)
{
	void* tmpnode = NULL;
	LinkQueueNode* tmp = (LinkQueueNode*)LinkList_Delete(linkqueue, 0);
	tmpnode = tmp->item;
	free(tmp);
	return tmpnode;
}
int LinkQueue_Length(LinkQueue* linkqueue)
{
	return LinkList_Length(linkqueue);
}
void* Linkqueue_Header(LinkQueue* linkqueue)
{
	LinkQueueNode* tmp = (LinkQueueNode*)LinkList_Get(linkqueue, 0);
	return tmp->item;
}

#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "SeqQueue.h"
#include "LinkQueue.h"

typedef struct tag_Teacher
{
	int age;
	char* name;
}Teacher;

void  TestDemo1()
{
	SeqQueue* mseqqueue;
	int length = 0, i = 0,capacity = 0;
	Teacher t1, t2, t3, t4, t5;
	t1.age = 11;
	t2.age = 22;
	t3.age = 33;
	t4.age = 44;
	t5.age = 55;
	t1.name = "shao11";
	t2.name = "shao22";
	t3.name = "shao33";
	t4.name = "shao44";
	t5.name = "shao55";
	mseqqueue = SeqQueue_Create(10);
	capacity = SeqQueue_Capacity(mseqqueue);
	SeqQueue_Append(mseqqueue, (void*)&t1);
	SeqQueue_Append(mseqqueue, (void*)&t2);
	SeqQueue_Append(mseqqueue, (void*)&t3);
	SeqQueue_Append(mseqqueue, (void*)&t4);
	SeqQueue_Append(mseqqueue, (void*)&t5);
	Teacher* mteacher = (Teacher*)SeqQueue_Header(mseqqueue);	
	printf("header node age:%d;node name:%s:capacity:%d\n", mteacher->age, mteacher->name,capacity);
	length = SeqQueue_Length(mseqqueue);
	printf("length of queue: %d\n", length);
	for (i = 0; i < length;i++)
	{
		Teacher* tmpteacher = (Teacher*)SeqQueue_Retrive(mseqqueue);
		printf("delete node age:%d;node name:%s\n", tmpteacher->age, tmpteacher->name);
	}
	SeqQueue_Destroy(mseqqueue);
}


void TestDemo2()
{
	LinkQueue* mlinkqueue;
	int length = 0, i = 0;
	Teacher t1, t2, t3, t4, t5;
	t1.age = 11;
	t2.age = 22;
	t3.age = 33;
	t4.age = 44;
	t5.age = 55;
	t1.name = "shao11";
	t2.name = "shao22";
	t3.name = "shao33";
	t4.name = "shao44";
	t5.name = "shao55";
	mlinkqueue =  LinkQueue_Create();
	LinkQueue_Append(mlinkqueue, (void*)&t1);
	LinkQueue_Append(mlinkqueue, (void*)&t2);
	LinkQueue_Append(mlinkqueue, (void*)&t3);
	LinkQueue_Append(mlinkqueue, (void*)&t4);
	LinkQueue_Append(mlinkqueue, (void*)&t5);
	
	Teacher* mteacher = (Teacher*)Linkqueue_Header(mlinkqueue);
	printf("header node age:%d;node name:%s\n", mteacher->age, mteacher->name);
	length = LinkQueue_Length(mlinkqueue);
	printf("length of queue: %d\n", length);
	for (i = 0; i < length;i++)
	{
		Teacher* tmpteacher = (Teacher*)LinkQueue_Retrive(mlinkqueue);
		printf("delete node age:%d;node name:%s\n", tmpteacher->age, tmpteacher->name);
	}
	LinkQueue_Destroy(mlinkqueue);

}


void main()
{
	TestDemo2();
	printf("邵忠棋\n");
	system("pause");
}

对自己写的底层库是不是很有信心！！！