栈的链式存储 - API实现

基本概念

其他概念详情参看前一篇博文:栈的顺序存储 - 设计与实现 - API实现

这里也是运用了链表的链式存储API快速实现了栈的API。

代码:

// linkstack.h
// 链式存储栈的API声明

#ifndef _MY_LINKSTACK_H_
#define _MY_LINKSTACK_H_

typedef void LinkStack;

// 创建栈
LinkStack* LinkStack_Create();

// 销毁栈
void LinkStack_Destroy(LinkStack* stack);

// 清空栈
void LinkStack_Clear(LinkStack* stack);

// 将item入栈
int LinkStack_Push(LinkStack* stack, void* item);

// 弹出栈顶元素
void* LinkStack_Pop(LinkStack* stack);

// 获取栈顶元素
void* LinkStack_Top(LinkStack* stack);

// 获取栈的大小
int LinkStack_Size(LinkStack* stack);

#endif //_MY_LINKSTACK_H_
// linkstack.cpp
// 链式存储栈的API实现

#include <stdio.h>
#include <malloc.h>
#include "linkstack.h"
#include "linklist.h"

typedef void LinkStack;

typedef struct _tag_LinkStack
{
	LinkListNode node;
	void* item;
}TLinkStack;

// 创建一个栈,相当于创建一个线性表
LinkStack* LinkStack_Create()
{
	return LinkList_Create();
}

// 销毁栈
void LinkStack_Destroy(LinkStack* stack)
{
	LinkStack_Clear(stack); // 释放栈的结点
	LinkList_Destroy(stack); // 释放句柄
	return;
}

// 清空栈
void LinkStack_Clear(LinkStack* stack)
{
	while (LinkList_Length(stack)) {
		LinkStack_Pop(stack);
	}
	return;
}

// 向栈中添加元素,相当于用头插法向线性表添加结点
int LinkStack_Push(LinkStack* stack, void* item)
{
	int ret = 0;
	TLinkStack *tStack = NULL;

	// 把void* item转化成链表结点
	tStack = (TLinkStack *)malloc(sizeof(TLinkStack));
	tStack->item = item;

	// 头插法插入结点
	ret = LinkList_Insert(stack, (LinkListNode *)tStack, 0);
	if (ret) {
		printf("function LinkStack_Push err: %d.\n", ret);
		free(tStack);
		return ret;
	}

	return ret;
}

// 弹出栈顶元素,相当于从线性表中删除0号元素
void* LinkStack_Pop(LinkStack* stack)
{
	TLinkStack *tStack = NULL;
	void* item = NULL;

	tStack = (TLinkStack *)LinkList_Delete(stack, 0);
	if (tStack == NULL) {
		printf("function LinkStack_Pop err.\n");
		return NULL;
	}

	// 把链表结点转化成栈结点
	item = tStack->item;
	free(tStack); // 记得释放创建时候malloc的内存

	return item;
}

// 获取栈顶元素
void* LinkStack_Top(LinkStack* stack)
{
	TLinkStack *tStack = NULL;
	void* item = NULL;

	tStack = (TLinkStack *)LinkList_Get(stack, 0);
	if (tStack == NULL) {
		printf("function LinkStack_Top err.\n");
		return NULL;
	}

	item = tStack->item;

	return item;
}

// 获取栈的大小
int LinkStack_Size(LinkStack* stack)
{
	return LinkList_Length(stack);
}
// main.cpp
// 栈链式存储的测试程序

#include <stdio.h>
#include "linkstack.h"

const int maxn = 5;

void play()
{
	int a[maxn];

	for (int i = 0; i < maxn; ++i) {
		a[i] = i + 1;
	}

	LinkStack *stack = NULL;

	stack = LinkStack_Create(); // 创建栈

	// 入栈
	for (int i = 0; i < maxn; ++i) {
		LinkStack_Push(stack, &a[i]);
	}

	// 栈属性
	printf("size: %d\n", LinkStack_Size(stack));
	printf("top: %d\n", *((int *)LinkStack_Top(stack)));

	LinkStack_Destroy(stack);
}

int main()
{
	play();

	return 0;
}
// linklist.h
#ifndef _MYLINKLIST_H_
#define _MYLINKLIST_H_

typedef void LinkList;

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

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

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

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

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

#endif
// linklist.cpp

#include <iostream>
#include <cstdio>
#include "linklist.h"

using namespace std;

typedef void LinkList;

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

LinkList* LinkList_Create()
{
	TLinkList *tmp = NULL;

	tmp = (TLinkList *)malloc(sizeof(TLinkList));
	if (tmp == NULL) {
		printf("function LinkList_Create() err.\n");
		return NULL;
	}
	memset(tmp, 0, sizeof(TLinkList)); // 初始化为空链表

	return tmp;
}

void LinkList_Destroy(LinkList* list)
{
	if (list == NULL) {
		return;
	}
	free(list);

	return;
}

void LinkList_Clear(LinkList* list)
{
	if (list == NULL) {
		return;
	}
	TLinkList *tList = NULL;
	tList = (TLinkList *)list;
	tList->header.next = NULL;
	tList->length = 0;

	return;
}

int LinkList_Length(LinkList* list)
{
	if (list == NULL) {
		return -1;
	}
	TLinkList *tList = NULL;
	tList = (TLinkList *)list;

	return tList->length;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
	if (list == NULL || node == NULL || pos < 0) {
		return -1;
	}
	TLinkList *tList = NULL;
	tList = (TLinkList *)list;
	LinkListNode *cur = NULL;
	cur = &(tList->header);

	// 对pos的容错处理,如果pos过大,改为最后面
	if (pos > LinkList_Length(list)) {
		pos = LinkList_Length(list);
	}

	// 移动到需要插入的位置
	for (int i = 0; i < pos; ++i) {
		cur = cur->next;
	}

	// 插入
	node->next = cur->next;
	cur->next = node;

	++tList->length;

	return 0;
}

LinkListNode* LinkList_Get(LinkList* list, int pos)
{
	if (list == NULL || pos < 0 || pos >= LinkList_Length(list)) {
		return NULL;
	}
	TLinkList *tList = NULL;
	tList = (TLinkList *)list;
	LinkListNode *cur = NULL;
	cur = &(tList->header);

	for (int i = 0; i < pos; ++i) {
		cur = cur->next;
	}

	return cur->next;
}

LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
	if (list == NULL || pos < 0 || pos >= LinkList_Length(list)) {
		return NULL;
	}
	TLinkList *tList = NULL;
	tList = (TLinkList *)list;
	LinkListNode *cur = NULL;
	cur = &(tList->header);

	for (int i = 0; i < pos; ++i) {
		cur = cur->next;
	}

	LinkListNode *ret = NULL;
	ret = cur->next;

	// 删除结点
	cur->next = ret->next;

	--tList->length;

	return ret;
}

工程代码详情:Github

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-12 17:58:09

栈的链式存储 - API实现的相关文章

栈的链式存储结构和入栈出栈操作

参考<大话数据结构>P98~99——栈的链式存储结构. 进栈: 出栈: 举个简单的例子: 代码和解释如下(VS2012测试通过): 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 typedef string status;//用书上推荐的status返回是否成功,C++中的模板类string比字符数组char[]更方便 6 7 //栈的结点 8 //包含data,和指向下一个结点

栈的链式存储及基本操作

栈的链式存储结构称为链栈,它是运算受限的单链表,其插入和删除操作仅限制在栈顶进行. 先将练习结果贴下 相关C代码如下: /*数据结构之栈*/ #include <stdio.h> #include <malloc.h> #include <stdlib.h> typedef int DataType; /*定义栈的结构体类型*/ typedef struct NODE{ DataType data; NODE * pNext; }Node,* PNode; typede

栈及栈的链式存储结构(栈链)

栈:线性结构,后进先出.栈(Stack)是一种特殊的线性表(顺序表,链表)只在表尾进行删除和插入操作. 注意:对于栈来说,表尾称为栈的栈顶(top),表头称为栈底(bottom). 栈也是线性结构的一种特例.与队列不同,他只有一个口,只能从这里读或者写数据,这个口称为栈顶(top).栈是一种先进后出的数据结构.先进来的元素会放入栈底,而后进来的元素被放在它的上面,最后进来的元素的上面的位置,称为栈顶. 栈所提供的操作比一般的线性表要少很多,只提供:初始化.销毁.判断是否为空.求栈的长度.清空栈.

数据结构 - 栈的链式存储

栈的链式存储 1 栈的链式表示 栈的链式存储结构称为链栈,是运算受限的单链表.其插入和删除操作只能在表头位置上进行.因此,链栈没有必要像单链表那样附加头结点,栈顶指针top就是链表的头指针.图3-4是栈的链式存储表示形式. 链栈的结点类型说明如下: typedef struct Snode { ElemType data ; struct Snode *next ; } SNode, *Link_Stack ; 链栈基本操作的实现 2 链栈基本操作的实现 (1) 栈的初始化 SNode *Ini

数据结构_线性表_顺序存储之1顺序栈2共享栈_链式存储之链栈_栈的应用举例

1>//栈是先进后出,后进先出的线性表 简称LIFO线性表 //栈的顺序存储结构成为顺序栈(sequebtial stack). //顺序栈利用一组地址连的存储单元依次存放从栈底到 栈顶的数据元素,通常用一维数组存放栈的元素 //"指针"top并非指针,而是表示栈顶元素的当前位置 //top不是指针型变量而是整形变量,top=0空栈,top=MaxSize 表示满栈,当top>maxsize 表示栈溢出 代码 #include <stdio.h> #includ

栈的链式存储结构及应用(C、Java代码)

链式存储结构最大的好处就是没有空间的限制,可以通过指针指向将结点像以链的形式把结点链接,我们熟悉的线性表就有链式存储结构. 当然,栈同样有链式存储结构,栈的链式存储结构,简称链栈. 从图片可以看到,和单链表很像,拥有一个头指针top,又称作栈顶指针,所以此时就不再需要单链表里面的头结点了. 对于链栈来说,基本不存在栈满的情况,除非计算机内存已经没有了可使用的空间,如果真的存在,那么计算机系统已经面临着即将死机崩溃的情况,而不是这个链栈是否溢出的问题了. 对于空栈来说,链表的定义是头指针指向NUL

栈的链式存储构架

定义 栈是限定只能在表尾删除和插入操作的线性表. 允许插入和删除的一端称为栈顶(top),另一端称为栈底(bottom).栈又称为后进先出(Last In First Out)的线性表,简称LIFO结构. 栈的插入操作称为进栈,也称压栈.入栈. 栈的删除操作称为出栈,也称弹栈. 栈的抽象数据结构 由于栈本身就是一个线性表,所以线性表的操作特性它都具备,针对它的特殊性,在它的操作上可能会有一些变化.将进栈和出栈分别改名为push和pop. 由于栈本身是一个线性表,所以线性表的顺序存储结构和链式存储

栈(链式存储结构)

堆栈:具有一定操作约束的线性表,只能在一端作插入.删除 具有后入先出的特性(Last In First Out) 分顺序存储结构.链式存储结构两种形式 堆栈的顺序存储结构 通常由一个一维数组和一个栈顶元素变量组成 图解如下: 形式一:构建结构体 0.结构初始化 #define MaxSize ### struct StackNode { ElementType Data[MaxSize]; int top; }; 1.建立空栈 struct StackNode* createStack() {

栈的链式存储结构(C语言实现)

1 #include <stdio.h> 2 #include <stdlib.h> 3 4 #define OK 1 5 #define ERR 2 6 #define TRUE 1 7 #define FALSE 0 8 9 typedef int status; //定义函数返回的状态,OK & ERR 10 typedef char datatype; //定义栈中每个元素的数据类型,这里暂定为字符型 11 12 typedef struct LinkStack_a