栈的链式存储设计与实现

//linklist.h
#ifndef _LINKLIST_H_
#define _LINKLIST_H_
#include<stdio.h>

typedef void LinkList;
typedef struct _tag_LinkListNode
{
	struct _tag_LinkListNode *next;
}LinkListNode;

LinkList *LinkList_Create();
void LinkList_Clear(LinkList *list);
void LinkList_Destroy(LinkList *list);

int LinkList_Length(LinkList *list);
int LinkList_Insert(LinkList *list, LinkListNode *node, int pos);

LinkListNode *LinkList_Delete(LinkList *list, int pos);
LinkListNode *LinkList_Get(LinkList *list, int pos);

#endif

//linkstack.h
#pragma once
typedef void LinkStack;

LinkStack* LinkStack_Create();

void LinkStack_Clear(LinkStack *stack);
void LinkStack_Destroy(LinkStack *stack);

int LinkStack_Size(LinkStack *stack);
int LinkStack_Push(LinkStack *stack,void *item);

void *LinkStack_Pop(LinkStack *stack);
void *LinkStack_Top(LinkStack *stack);

//linklist.cpp
#include "linklist.h"
#include<stdlib.h>

typedef struct _tag_LinkList
{
	LinkListNode header;
	int length;
}TLinkList;

LinkList *LinkList_Create()
{
	TLinkList *ret = (TLinkList *)malloc(sizeof(TLinkList));
	if (ret == NULL)
	{
		printf("LinkList_Create err:malloc err\n");
		return NULL;
	}
	ret->header.next = NULL;
	ret->length = 0;
	return ret;
}

void LinkList_Clear(LinkList *list)
{
	TLinkList *tlist = (TLinkList*)list;
	if (list == NULL)
	{
		printf("LinkList_Clear err\n");
		return;
	}
	tlist->header.next = NULL;
	tlist->length = 0;
}

void LinkList_Destroy(LinkList *list)
{
	if (list != NULL)
	{
		free(list);
	}
	else
	{
		printf("LinkList_Destroy err\n");
	}
}

int LinkList_Length(LinkList *list)
{
	TLinkList *tlist = (TLinkList*)list;
	if (list == NULL)
	{
		printf("LinkList_Length err\n");
		return -1;
	}
	return tlist->length;
}

int LinkList_Insert(LinkList *list, LinkListNode *node, int pos)
{
	int i = 0;
	TLinkList *tlist = (TLinkList *)list;
	LinkListNode *current = NULL;
	if (list == NULL || node == NULL || pos < 0)
	{
		printf("LinkList_Insert err\n");
		return -1;
	}
	current = (LinkListNode*)tlist;
	for (i = 0; i < pos&¤t->next != NULL; i++)
	{
		current = current->next;
	}
	node->next = current->next;
	current->next = node;
	tlist->length++;
	return pos;
}

LinkListNode* LinkList_Get(LinkList *list, int pos)
{
	int i = 0;
	TLinkList *tlist = (TLinkList *)list;
	LinkListNode *current = NULL;
	LinkListNode *ret = NULL;
	if (list == NULL || pos < 0)
	{
		printf("LinkList_Get err\n");
		return NULL;
	}
	current = (LinkListNode*)tlist;
	for (i = 0; i < pos&¤t->next != NULL; i++)
	{
		current = current->next;
	}
	ret = current->next;
	if (ret == NULL)
	{
		printf("LinkList_Get err\n");
		return ret;
	}
	return ret;

}

LinkListNode *LinkList_Delete(LinkList *list, int pos)
{
	int i = 0;
	TLinkList *tlist = (TLinkList *)list;
	LinkListNode *current = NULL;
	LinkListNode *ret = NULL;
	if (list == NULL || pos < 0)
	{
		printf("LinkList_Delete err\n");
		return NULL;
	}
	current = (LinkListNode *)tlist;
	for (i = 0; i < pos&¤t->next != NULL; i++)
	{
		current = current->next;
	}
	ret = current->next;
	current->next = ret->next;
	tlist->length--;
	return ret;
}

//linkstack.cpp
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include "linklist.h"
#include "linkstack.h"

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

LinkStack *LinkStack_Create()
{
	return LinkList_Create();
}

void LinkStack_Clear(LinkStack *stack)
{
	while (LinkStack_Size(stack) > 0)
	{
		LinkStack_Pop(stack);
	}
}

void LinkStack_Destroy(LinkStack *stack)
{
	LinkStack_Clear(stack);
	LinkList_Destroy(stack);
}

int LinkStack_Size(LinkStack *stack)
{
	return LinkList_Length(stack);
}

int LinkStack_Push(LinkStack *stack, void *item)
{
	int ret = 0;
	TLinkStackNode *tmp = (TLinkStackNode*)malloc(sizeof(TLinkStackNode));
	if (tmp == NULL)
	{
		ret = -1;
		printf("LinkStack_Push err %d\n", ret);
		return ret;
	}
	tmp->item = item;
	ret = LinkList_Insert(stack, (LinkListNode*)&tmp->node,0);
	if (ret != 0)
	{
		ret = -2;
		printf("LinkStack_Push err %d\n", ret);
	}
	return ret;
}

void *LinkStack_Pop(LinkStack *stack)
{
	void *ret = NULL;
	TLinkStackNode *tmp = NULL;
	tmp = (TLinkStackNode *)LinkList_Delete(stack, 0);
	if (tmp == NULL)
	{
		printf("LinkStack_Pop err:LinkList_Delete\n");
		return NULL;
	}
	ret = tmp->item;
	free(tmp);
	return ret;
}

void *LinkStack_Top(LinkStack *stack)
{
	TLinkStackNode *tmp = (TLinkStackNode *)LinkList_Get(stack, 0);
	if (tmp == NULL)
	{
		printf("LinkStack_Top err\n");
		return NULL;
	}
	return tmp->item;
}

//栈的链式存储设计与实现
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "linkstack.h"

void main()
{
	int a[10], i;
	LinkStack *stack = NULL;

	stack = LinkStack_Create();

	for (i = 0; i<10; i++)
	{
		a[i] = i + 1;
		LinkStack_Push(stack, &a[i]);
	}
	printf("top: %d \n", *((int *)LinkStack_Top(stack)));
	printf("size: %d \n", LinkStack_Size(stack));

	//删除栈中所有元素
	while (LinkStack_Size(stack) > 0)
	{
		printf("linkstack pop: %d \n", *((int*)LinkStack_Pop(stack)));
	}
	LinkStack_Destroy(stack);

	system("pause");
}