链式栈与链式队列

最新推荐文章于 2023-08-25 16:09:14 发布
最新推荐文章于 2023-08-25 16:09:14 发布
阅读量539 收藏 10
点赞数 6
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71637218/article/details/132008222
版权

链式栈

定义

链式栈（Linked Stack）是一种基于链表实现的栈（Stack）数据结构。栈是一种具有特定限制条件的线性数据结构，其中元素的插入和删除操作只能在一端进行，该端称为栈顶（Top）。链式栈通过使用链表来存储元素，每个节点包含一个数据元素和一个指向下一个节点的指针。

特点

  1. 动态大小：链式栈的大小可以根据需要进行动态调整，不受固定大小的限制。链表结构充分利用了内存空间，可以灵活地增加或删除节点，从而适应不同的数据规模。

  2. 堆内存分配：链式栈的节点是通过堆内存动态分配而成的，而不是通过数组进行连续存储。这意味着链式栈可以处理更大的数据量，不会受到栈空间大小的限制。

  3. 添加和删除操作效率高：由于链式栈采用了链表结构，插入和删除操作只需要调整节点的指针，时间复杂度为O(1)。因此，无论是入栈还是出栈操作，都能够在常数时间内完成。

代码实现

节点描述

typedef struct LNode {
	int val;
	LNode* next;
}LNode;

栈描述

typedef struct LinkStack {
	LNode* head;
	int size;
}LinkStack;

初始化

void InitStack(LinkStack* slink) {
	assert(slink != NULL);
	slink->head = NULL;
	slink->size = 0;
}

创建节点

LNode* CreatNode(int val) {
	LNode* p = (LNode*)malloc(sizeof(LNode));
	assert(p != NULL);
	p->val = val;
	p->next = NULL;
	return p;
}

判空

bool IsEmpty(LinkStack* slink) {
	return slink->size == NULL;
}

入栈

bool Push(LinkStack* slink, int val) {
	assert(slink != NULL);
	LNode* p = CreatNode(val);
	p->next = slink->head;
	slink->head = p;
	slink->size++;
	return true;
}

出栈

bool Pop(LinkStack* slink) {
	if (IsEmpty(slink)) {
		return false;
	}
	else {
		LNode* p = slink->head;
		slink->head = p->next;
		free(p);
		return true;
	}
}

获取栈顶元素

bool GetTop(LinkStack* slink,int* pval) {
	if (IsEmpty(slink)) {
		*pval = 0;
		return false;
	}
	else {
		*pval = slink->head->val;
		return true;
	}
}

获取栈中有效元素个数

int GetSize(LinkStack* slink) {
	return slink->size;
}

清空栈

void ClearStack(LinkStack* slink) {
	LNode* p = slink->head;
	while (p->next != NULL) {
		p->val = 0;
		p = p->next;
	}
}

销毁栈

void DestoryStack(LinkStack* slink) {
	while (Pop(slink));
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
typedef struct LNode {
	int val;
	LNode* next;
}LNode;
typedef struct LinkStack {
	LNode* head;
	int size;
}LinkStack;
LNode* CreatNode(int val) {
	LNode* p = (LNode*)malloc(sizeof(LNode));
	assert(p != NULL);
	p->val = val;
	p->next = NULL;
	return p;
}
void InitStack(LinkStack* slink) {
	assert(slink != NULL);
	slink->head = NULL;
	slink->size = 0;
}
bool IsEmpty(LinkStack* slink) {
	return slink->size == NULL;
}
bool Push(LinkStack* slink, int val) {
	assert(slink != NULL);
	LNode* p = CreatNode(val);
	p->next = slink->head;
	slink->head = p;
	slink->size++;
	return true;
}
bool Pop(LinkStack* slink) {
	if (IsEmpty(slink)) {
		return false;
	}
	else {
		LNode* p = slink->head;
		slink->head = p->next;
		free(p);
		return true;
	}
}
bool GetTop(LinkStack* slink,int* pval) {
	if (IsEmpty(slink)) {
		*pval = 0;
		return false;
	}
	else {
		*pval = slink->head->val;
		return true;
	}
}
int GetSize(LinkStack* slink) {
	return slink->size;
}
void ClearStack(LinkStack* slink) {
	LNode* p = slink->head;
	while (p->next != NULL) {
		p->val = 0;
		p = p->next;
	}
}
void DestoryStack(LinkStack* slink) {
	while (Pop(slink));
}

链式队列

定义

链式队列是一种队列，其元素使用链表结构存储，每个节点包含存储的数据和指向下一个节点的指针。链式队列的队首和队尾分别由链表的头节点和尾节点来表示。

特点

  1. 动态大小： 链式队列的大小（元素个数）可以根据需要动态调整，不像顺序队列有固定的容量限制。这使得链式队列可以灵活地处理不同规模的数据。

  2. 无需搬移元素： 在链式队列中进行入队和出队操作不需要搬移元素。在链表结构中，新元素的入队只需要简单地创建一个新节点，并更新队尾指针，而出队只需要将头节点移除，并更新队首指针。这使得链式队列的入队和出队操作的时间复杂度都是 O(1)。

  3. 内存动态管理： 链式队列通过动态分配和释放内存来管理队列的元素，可以更加灵活地利用内存资源，避免了静态数组可能出现的内存浪费问题。

  4. 容易扩展： 链式队列支持动态大小，当需要更多的空间时，可以很容易地添加新的节点来扩展队列。相比之下，顺序队列的扩展则需要重新分配更大的静态数组，并搬移现有元素，较为繁琐。

代码实现

节点描述

typedef struct LNode {
	int val;
	LNode* next;
}LNode;

队列描述

typedef struct LinkQueue {
	LNode* head;
	LNode* tail;
	int size;
}LinkQueue;

初始化

void InitQueue(LinkQueue* queue) {
	assert(queue!= NULL);
	queue->head = queue->tail = NULL;
	queue->size = 0;
}

创建节点

LNode* CreatLNode(int val) {
	LNode* p = (LNode*)malloc(sizeof(LNode));
	assert(p != NULL);
	p->val = val;
	p->next = NULL;
	return p;
}

判空

bool IsEmpty(LinkQueue* queue) {
	return queue->size == 0;
}

入队

bool PushQueue(LinkQueue* queue, int val) {
	assert(queue != NULL);
	LNode* p = CreatLNode(val);
	if (queue->tail == NULL) {
		queue->tail = queue->head = p;
	}
	else {
		queue->tail->next = p;
		queue->tail = p;
	}
	queue->size++;
	return true;
}

出队

bool PopQueue(LinkQueue* queue) {
	if (IsEmpty(queue)) {
		return false;
	}
	else {
		if (queue->size == 1) {
			queue->tail = queue->head = NULL;
		}
		else
		{
			LNode* p = queue->head;
			queue->head = p->next;
			free(p);
		}
		queue->size--;
		return true;
	}
}

获取队首元素

bool GetHead(LinkQueue* queue, int* pval) {
	if (IsEmpty(queue)) {
		*pval = 0;
		return false;
	}
	else {
		*pval = queue->head->val;
		return true;
	}
}

获取队列中有效元素个数

int GetSize(LinkQueue* queue) {
	return queue->size;
}

清空队列

void ClearQueue(LinkQueue* queue) {
	LNode* p = queue->head;
	while (p->next != NULL) {
		p->val = 0;
		p = p->next;
	}
}

销毁队列

void DestoryQueue(LinkQueue* queue) {
	while (PopQueue(queue));
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
typedef struct LNode {
	int val;
	LNode* next;
}LNode;
typedef struct LinkQueue {
	LNode* head;
	LNode* tail;
	int size;
}LinkQueue;
LNode* CreatLNode(int val) {
	LNode* p = (LNode*)malloc(sizeof(LNode));
	assert(p != NULL);
	p->val = val;
	p->next = NULL;
	return p;
}
void InitQueue(LinkQueue* queue) {
	assert(queue!= NULL);
	queue->head = queue->tail = NULL;
	queue->size = 0;
}
bool IsEmpty(LinkQueue* queue) {
	return queue->size == 0;
}
bool PushQueue(LinkQueue* queue, int val) {
	assert(queue != NULL);
	LNode* p = CreatLNode(val);
	if (queue->tail == NULL) {
		queue->tail = queue->head = p;
	}
	else {
		queue->tail->next = p;
		queue->tail = p;
	}
	queue->size++;
	return true;
}
bool PopQueue(LinkQueue* queue) {
	if (IsEmpty(queue)) {
		return false;
	}
	else {
		if (queue->size == 1) {
			queue->tail = queue->head = NULL;
		}
		else
		{
			LNode* p = queue->head;
			queue->head = p->next;
			free(p);
		}
		queue->size--;
		return true;
	}
}
bool GetHead(LinkQueue* queue, int* pval) {
	if (IsEmpty(queue)) {
		*pval = 0;
		return false;
	}
	else {
		*pval = queue->head->val;
		return true;
	}
}
int GetSize(LinkQueue* queue) {
	return queue->size;
}
void ClearQueue(LinkQueue* queue) {
	LNode* p = queue->head;
	while (p->next != NULL) {
		p->val = 0;
		p = p->next;
	}
}
void DestoryQueue(LinkQueue* queue) {
	while (PopQueue(queue));
}

z53545556
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
链栈和链队列的实现
11-19
链栈和链队列的实现，用二级指针实现出栈、入栈，展示了二级指针的用法
链栈与链队列
weixin_45461859的博客
12-27 861
链栈 链栈的定义 栈的链式存储结构 链栈：即用链表实现栈存储结构 栈顶：允许插入和删除的一端（top） 栈底：不同于栈顶的另外一端（bottom） 空栈：不含任何元素的栈 链栈实际上就是一个只能采用头插法插入或删除数据的链表 //链栈表示 struct link{ int data; struct link *next; }; //链栈初始化 void initstack(struct ...
链式栈和链式队
Mormont的博客
11-28 676
1.链式栈： 栈的链式存储结构, 简称链栈。 /*链栈的结构代码*/  typedef struct stackNode { SElemType data; struct stackNode *next; } stackNode ,*LinkStackPtr; typedef struct LinkStack { LinkStackPtr  top; int count;
数据结构之链式队列与链式栈
Holmes_G的博客
03-27 428
“链式”即 链表式 1、链式栈typedef struct Taglinkstack { char ch; struct Taglinkstack * next; }Linkstack; //初始化 void LinkStack_Init(Linkstack * top) { top-&gt;ch = 0; top-&gt;next = NULL; } //判空 char StackEmp...
链栈和链队列的类实现
dliverol30914的博客
10-19 155
#include<iostream>#include<cassert> using namespace std; template <class T>//链栈 struct LinkNode{T data;LinkNode<T> *Link;LinkNode(LinkNode<T> *pr=NULL){Link=pr;}Li...
链表模版、链式队列与链式栈（C++）
10-15
本文将详细讲解链表模板、链式队列和链式栈的概念，以及如何用C++实现它们。 首先，让我们从双向链表模板开始。双向链表与单向链表不同，它具有前驱和后继节点的概念，每个节点不仅包含数据，还包含两个指针，分别...
c++链式栈类
03-26
在C++编程中，链式栈是一种非常重要的数据结构，它是栈的一种实现方式，与顺序栈（数组实现）相比，链式栈具有更好的灵活性。在本项目中，我们重点讨论如何使用C++来定义和实现一个链式栈类，以及验证其基本功能，如...
C++中实现队列类链式存储与栈类链式存储的代码示例
09-02
- `clear()`函数与队列类似，通过删除链表的所有元素清空栈。 - `push()`函数在链表头部插入元素，实现入栈。 - `pop()`函数删除并返回链表的第一个元素，实现出栈。 - `top()`函数获取链表的第一个元素而不删除，即...
LinkQueue-LinkStack.zip_linux队列_链式队列
09-22
链式队列与链式栈是数据结构中的两种重要概念，它们在计算机科学尤其是软件开发中扮演着核心角色。在本项目"LinkQueue-LinkStack.zip"中，开发者提供了C语言实现的链式队列和链式栈的代码示例。下面我们将详细探讨这...
C++数据结构之链式队列实现
09-20
链式队列与数组实现的队列相比，优点在于动态扩展能力，它不需要预先确定队列的大小。 ### 2. 链式队列的节点结构 链式队列通常由一系列节点组成，每个节点包含一个数据域和一个指针域。在C++中，可以定义一个...
Java实现链栈和链队列
LiangCJP的博客
08-23 427
继上次更新，同样将以前C++的实现转换为Java实现。 先来看看链栈 import javax.print.attribute.Size2DSyntax; public class LinkStack&lt;E&gt; { private Node&lt;E&gt; top; //栈顶元素 private int size; class Node&lt;E&gt;{ E e;...
java实现链栈与队列
bigevil的专栏
04-05 681
java实现链栈与顺序表队列。链栈的实现没有什么难点，跟单链表差不多，只是所有的操作只在表头进行，并且没有头节点，使用top标记。关键的操作是push与pop。
【算法设计-链栈和链队列】链栈和链队列的实现
wodeai1625的专栏
05-07 1084
1.链队列。利用带有头结点的单链表来实现链队列,插入和删除的复杂度都为o(1) 代码： #include #include typedef struct Qnode {  int data;  Qnode *next; }Qnode; typedef struct LinkQueue { Qnode *front; Qnode *rear; }LinkQueue; vo
手动实现 链式栈结构、链式队列
weixin_44579258的博客
05-20 146
** * 实现一个链式栈结构 * @param <T> */ class LinkStacked<T>{ /** * 链表的节点类型定义 * @param <T> */ static class Entry<T>{ T data; Entry<T> nex...
链表栈和队列的实现
HMT的博客
10-25 159
链表栈和队列 栈 #include "nodes.h" // 链表栈 /* 带头指针，头指针的值表示栈的深度 */ SNode* createStack() { return createSNode(0); } // 入栈 void stack_push(SNode* shead, int value) { addSNodeToTheNext(shead, createSNode(value)); shead->value++; } // 出栈 SNode* stack_p
链式栈和链式队列的简单思路
最新发布
sunres的博客
08-25 93
链式队列和链式栈的简单写法，一通万通
数据结构--链式栈与链式队列设计与实现（c++描述）
m0_54759841的博客
03-16 1648
链式栈与链式队列的设计与实现（c++描述） 本文主要讨论的是链式栈与链式队列的设计思想与实现对于链表的基本知识此处不予过多讨论 链式栈 链栈结构描述 见下图 几点解释说明： 此处栈顶指针也即表头指针，因为此处选择的链表为单向链表，无法从当前结点得出其前驱结点，由于栈的操作均在一端进行因此将栈顶指针设在表头更便于进行出栈和入栈 此处我选择使用count主要是因为考虑到如果说要获取栈内元素个数时，通过count能节省再去遍历链表获得存储空间造成的时间浪费，属于以空间换时间。 由于是链式结构，存储空间是我们n
栈和队列的实现
Z5433523的博客
08-21 222
栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”，另一固定端称为 “栈底”，当栈中没有元素时称为“空栈”。特点 ：后进先出(LIIFO)。队列是一种特殊的线性表，特殊之处就在于它只允许在表的前端进行删除操作，在表的后端进行 插入操作。和栈一样，队列也是一种操作受到限制的线性表。进行插入操作的端称之为队尾，进行删除操作的端称之为队头。队列中没有队列的时候，称之为空队列。队列的数据元素，⼜叫做队列元素。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值