双向链表，顺序栈，顺序队列，链式队列

最新推荐文章于 2025-08-04 22:37:45 发布
原创 最新推荐文章于 2025-08-04 22:37:45 发布 · 161 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #链表

1.双向链表

功能函数
#include <stdio.h>
#include <stdlib.h>
#include "./01_doublelinklist.h"

/*
 * function:    创建双向链表
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DoubleLinklist* create_doublelinklist()
{
	DoubleLinklist* head=(DoubleLinklist*)malloc(sizeof(DoubleLinklist));
	if(head==NULL)
	{
		printf("双向链表创建失败");
		return NULL;
	}

	head->msg.len=0;
	head->prev=NULL;
	head->next=NULL;

	return head;
}



/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int insert_doulielinklist(DoubleLinklist* head,datatype num)
{
	DoubleLinklist* temp=(DoubleLinklist*)malloc(sizeof(DoubleLinklist));
	if(temp==NULL)
	{
		printf("创建双向链表失败");
	}
	temp->msg.data=num;
	temp->next=NULL;
	temp->prev=NULL;

	//修改next指针域
	temp->next=head->next;
	head->next=temp;
	//修改prev指针域
	if(temp->next==NULL)
	{
		temp->prev=head;	
    	head->msg.len++;
	}
	else
	{
		temp->prev=temp->next->prev;
		temp->next->prev=temp;	
     	head->msg.len++;
	}

	return head->msg.len;
}


/*
 * function:    遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void show_doublelinklist(DoubleLinklist *head)
{
	if(head->next==NULL)
	{
		printf("双向链表为空");
		return;
	}

	DoubleLinklist *p=head;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%d ",p->msg.data);
	}
	putchar(10);
	return;
}

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int insert_doulielinklist_tail(DoubleLinklist *head,datatype num)
{
	DoubleLinklist* temp=(DoubleLinklist*)malloc(sizeof(DoubleLinklist));
	if(temp==NULL)
	{
		printf("创建双向链表失败");
	}
	temp->msg.data=num;
	temp->next=NULL;
	temp->prev=NULL;
	
	DoubleLinklist* p=head;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	temp->next=p->next;
	p->next=temp;

	temp->prev=p;

	head->msg.len++;

	return head->msg.len;

}


/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype del_doublelinklist_head(DoubleLinklist *head)
{
	if(head->next==NULL)
	{
		printf("双向链表为空,删除失败");
		return (datatype)-1;
	}
	

	DoubleLinklist *temp=head->next;
	datatype d=temp->msg.data;
	//修改next指针
	head->next=temp->next;
	//修改prev域
	if(temp->next!=NULL)
	{
		temp->next->prev=temp->prev;
	}
	free(temp);
	temp=NULL;

	head->msg.len--;
	return d;
}


/*
 * function:    尾删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype del_doublelinklist_tail(DoubleLinklist *head)
{
	if(head->next==NULL)
	{
		printf("双向链表为空,删除失败");
		return (datatype)-1;
	}

	DoubleLinklist* p=head;
	while(p->next->next!=NULL)
	{
		p=p->next;
	}
	DoubleLinklist* temp=p->next;
	datatype n=temp->msg.data;
	p->next=temp->next;

	free(temp);
	temp=NULL;

	head->msg.len--;
	return n;

}

/*
 * function:    按指定位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int insert_doulielinklist_ByIndex(DoubleLinklist *head,int index,datatype num)
{
	if(head==NULL)
	{
		printf("链表不存在，插入数据失败");
		return -1;
	}

	if(index<1)
	{
		printf("数据插入不合法");
		return -1;
	}

	DoubleLinklist* temp=(DoubleLinklist*)malloc(sizeof(DoubleLinklist));
	if(temp==NULL)
	{
		printf("创建双向链表失败");
	}
	temp->msg.data=num;
	temp->next=NULL;
	temp->prev=NULL;

	DoubleLinklist *p=head;
	for(int i=0;i<index-1;i++)
	{
		p=p->next;
		if(p==NULL)
		{
			printf("错误，插入数据位置不合法");
			return -1;
		}
	}
	//修改next域
	temp->next=p->next;
	p->next=temp;

	//修改prev域
	temp->prev=p;
	if(temp->next!=NULL)
	{
		temp->next->prev=temp;
	}

	head->msg.len++;

	return head->msg.len;

}

/*
 * function:    按指定位置删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype del_doublelinklist_ByIndex(DoubleLinklist *head,int index)
{
	if(head->next==NULL)
	{
		printf("双向链表为空,删除失败\n");
		return (datatype)-1;
	}

	if(index<1)
	{
		printf("删除数据位置不合法\n");
		return (datatype)-1;
	}
	DoubleLinklist* p=head;
	for(int i=0;i<index;i++)
	{
		p=p->next;
		if(p==NULL)
		{
			printf("删除数据位置不合法，删除失败\n");
			return (datatype)-1;
		}
	}

	datatype d=p->msg.data;
	//修改next域
	p->prev->next=p->next;
	//修改prev域
	if(p->next!=NULL)
	{
		p->next->prev=p->prev;
	}

	free(p);
	p=NULL;
	
	head->msg.len--;

	return d;


}
头文件
#ifndef __DOUBLE_LINKLIST_H__
#define __DOUBLE_LINKLIST_H__

typedef int datatype;
typedef struct dblink
{
	union
	{
		int len;
		datatype data;
	}msg;
	struct dblink* prev;
	struct dblink* next;
}DoubleLinklist;
//创建双向链表
DoubleLinklist* create_doublelinklist();

//头插
int insert_doulielinklist(DoubleLinklist* head,datatype num);
//遍历
void show_doublelinklist(DoubleLinklist *head);
//尾插
int insert_doulielinklist_tail(DoubleLinklist *head,datatype num);
//头删
datatype del_doublelinklist_head(DoubleLinklist *head);
//尾删
datatype del_doublelinklist_tail(DoubleLinklist *head);
//指定位置插入
int insert_doulielinklist_ByIndex(DoubleLinklist *head,int index,datatype num);
//指定位置删除
datatype del_doublelinklist_ByIndex(DoubleLinklist *head,int index);

#endif
运行结果

2.顺序栈

功能函数
#include <stdio.h>
#include <stdlib.h>
#include "./01_seqlist_stack.h"


int isFull_seqstack(Seqstack *st);
/*
 * function:   创建栈 
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Seqstack* create_seqlistStack()
{
	Seqstack* st=(Seqstack*)malloc(sizeof(Seqstack));
	if(st==NULL)
	{
		printf("栈为空");
		return NULL;
	}
	st->pos=0;

	return st;
}


/*
 * function:    入栈
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void push_stack(Seqstack *st,datatype num)
{
	if(isFull_seqstack(st))
	{
		printf("满栈，入栈失败");
		return;
	}

	st->data[st->pos]=num;
	st->pos++;

	return;
}

/*
 * function:    出栈
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype pop_stack(Seqstack *st)
{
	if(st->pos==0)
	{
		printf("空栈");
		return (datatype)-1;
	}
	st->pos--;
	datatype d=st->data[st->pos];
/*
	for(int i=st->pos;i>=0;i--)
	{
		printf("%d ",st->data[i]);
	}
*/
	return d;
}

/*
 * function:    判满
 * @param [ in] 
 * @param [out] 
 * @return      为满返回1，不满返回0
 */
int isFull_seqstack(Seqstack *st)
{
	return st->pos==N?1:0;
}


/*
 * function:    遍历栈
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void show_stack(Seqstack *st)
{
	if(st->pos==0)
	{
		printf("空栈");
		return;
	}

	for(int i=0;i<st->pos;i++)
	{
		printf("%d ",st->data[i]);
	}

	putchar(10);
	return;
}
头文件
#ifndef __SEQLIST_STACK_H__
#define __SEQLIST_STACK_H__
#define N 7

typedef int datatype;
typedef struct
{
	datatype data[N];
	int pos;
}Seqstack;


//创建栈
Seqstack* create_seqlistStack();

//入栈
void push_stack(Seqstack *st,datatype num);
//出栈
datatype pop_stack(Seqstack *st);

//遍历栈
void show_stack(Seqstack *st);

#endif
运行结果

3.顺序队列

功能函数
#include <stdio.h>
#include <stdlib.h>
#include "./02_seqQueue.h"


/*
 * function:    创建队列
 * @param [ in] 
 * @param [out] 
 * @return      
 */
SeqQueue* create_seqQueue()
{
	SeqQueue* sq=(SeqQueue*)malloc(sizeof(SeqQueue));
	if(sq==NULL)
	{
		printf("队列为空");
		return NULL;
	}

	sq->front=sq->rear=0;

	return sq;
}

/*
 * function:    判满
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int isFull_seqQueue(SeqQueue *sq)
{
	return (sq->rear+1)%(N+1)==sq->front?1:0;
}

//判空
int isNULL_seqQueue(SeqQueue *sq)
{
	return sq->rear==sq->front?1:0; 
}

/*
 * function:    入队
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void input_seqQueue(SeqQueue *sq,datatype num)
{
	if(isFull_seqQueue(sq))
	{
		printf("队列已满，入队失败");
		return;
	}
	sq->data[sq->rear]=num;
	sq->rear=(sq->rear+1)%(N+1);
	return;
}


/*
 * function:    出队列
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype output_seqQueue(SeqQueue *sq)
{
	if(isNULL_seqQueue(sq))
	{
		printf("对列为空，出对失败\n");
		return (datatype)-1;
	}
	datatype n=sq->data[sq->front];
	sq->front=((sq->front)+1)%(N+1);

	return n;
}


/*
 * function:    遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void show_seqQueue(SeqQueue *sq)
{
	if(isNULL_seqQueue(sq))
	{
		printf("对列为空，出对失败");
		return;
	}
	for(int i=sq->front;i!=sq->rear;i=(i+1)%(N+1))
	{
		printf("%d ",sq->data[i]);
	}
	putchar(10);
	return;
}

/*
 * function:    计算个数
 * @param [ in] 
 * @param [out] 
 * @return      
 */

int countNum_seqQueue(SeqQueue* sq)
{
	int count;
	count=(sq->rear-sq->front+N+1)%(N+1);
	return count;
}
头文件
#ifndef __SEQ_QUEUE_H__
#define __SEQ_QUEUE_H__

#define N 5
typedef int datatype;
typedef struct
{
	datatype data[N+1];
	int front;
	int rear;
}SeqQueue;
//创建队列
SeqQueue* create_seqQueue();
//入队操作
void input_seqQueue(SeqQueue *sq,datatype num);
//出队操作
datatype output_seqQueue(SeqQueue *sq);
//遍历
void show_seqQueue(SeqQueue *sq);
//计算个数
int countNum_seqQueue(SeqQueue* sq);
#endif
运行结果

4.链式队列

功能函数
#include <stdio.h>
#include <stdlib.h>
#include "./01_linkqueue.h"


/*
 * function:    创建链表
 * @param [ in] 
 * @param [out] 
 * @return      
 */
QueueFR* create_linkqueue()
{
	QueueFR* qfr=(QueueFR*)malloc(sizeof(QueueFR));
	qfr->front=(LinkQueue*)malloc(sizeof(LinkQueue));
	if(qfr->front==NULL)
	{
		printf("链式队列创建失败");
		return NULL;
	}

	qfr->front->msg.len=0;

	qfr->front->next=NULL;
	qfr->rear=qfr->front;
	
	return qfr;
}

/*
 * function:    尾插入队
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void insert_linkqueue(QueueFR* qfr,datatype num)
{
	LinkQueue* temp=(LinkQueue*)malloc(sizeof(LinkQueue));
	if(temp==NULL)
	{
		printf("结点创建失败");
		return;
	}
	temp->msg.data=num;
	temp->next=NULL;

	temp->next=qfr->rear->next;
	qfr->rear->next=temp;

	qfr->rear=temp;
	qfr->front->msg.len++;
	return;
}

/*
 * function:    判空
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int isEmpty_linkqueue(QueueFR* qfr)
{
	return qfr->front==qfr->rear?1:0;	
}

/*
 * function:    遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void show_linkqueue(QueueFR* qfr)
{
	if(isEmpty_linkqueue(qfr))
	{
		printf("链式队列为空");
		return;
	}
	
	LinkQueue* p=qfr->front;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%d ",p->msg.data);
	}

	putchar(10);
	return;
}


/*
 * function:   头删,出队 
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype output_linkqueue(QueueFR* qfr)
{
	if(isEmpty_linkqueue(qfr))
	{
		printf("链式队列为空，错误");
		return (datatype)-1;
	}

	LinkQueue* temp=qfr->front->next;
	qfr->front->next=temp->next;

	datatype n=temp->msg.data;
	free(temp);
	if(qfr->front->next==NULL)
	{
		qfr->rear=qfr->front;
	}
	qfr->front->msg.len--;
	return n;

}
头文件
#ifndef __LINK_QUEUE_H__
#define __LINK_QUEUE_H__
typedef int datatype;
typedef struct lnk
{
	union{
		int len;
		datatype data;
	}msg;
	struct lnk* next;
}LinkQueue;
typedef struct{
	LinkQueue* front;
	LinkQueue* rear;
}QueueFR;

//创建链式队列
QueueFR* create_linkqueue();
//入队
void insert_linkqueue(QueueFR* qfr,datatype num);
//遍历
void show_linkqueue(QueueFR* qfr);

//头删，出队
datatype output_linkqueue(QueueFR* qfr);
#endif
运行结果：

青うそ衫
关注
数据结构(Java)——Day10(双向链表，栈)
LengchenAl的博客
11-24 862
数据结构(Java)——Day10(双向链表，栈)
3. java线性表（顺序表、链表、栈、队列）
kuxiaoyang的博客
01-06 1692
线性表是一种经典的数据结构，它遵循线性逻辑结构的特点。 数据元素之间具有“**一对一**”的逻辑关系。 第一个数据元素没有前驱，这个数据元素被称为**头结点**。 最后一个数据元素没有后继，这个数据元素被称为**尾节点**。除了第一个数据元素和最后一个数据元素外，其余的数据元素有且仅有唯一前驱和后继。前驱元素：若元素A在B元素的前面，则A为B的前驱元素。后继元素：若元素B在元素A的后面，则B为A的后继元素。
栈、队列、链表
tn1949的博客
09-19 1073
《啊哈！算法》学习笔记，三者都不是结构体、数组这种数据类型，我认为更像是一种算法。
数据结构：链表、栈、队列
2401_84247058的博客
08-14 2187
本文介绍了数据结构中链表、栈、队列的相关知识，并给出了定义和使用示例。
双向链表、顺序栈、顺序队列、链式队列实现函数
qq_52417518的博客
06-05 212
【代码】双向链表、顺序栈、顺序队列、链式队列实现函数。
python栈和队列的顺序和链式实现,简述顺序表、链表、栈和队列以及队列实现栈、栈实现队列...
weixin_35094438的博客
03-26 265
顺序表Vector原理顺序表存储是将数据元素放到一块连续的内存存储空间，相邻数据元素的存放地址也相邻(逻辑与物理统一)。使用方法添加：insert / push_back删除：erase / pop_back / clear访问：at / back / begin / end / []判断是否为空：empty元素个数：size优点和缺点1.优点：(1)空间利用率高。(局部性原理，连续存放，命中率高...
Java版基础数据结构算法 - 单链表和双向链表、顺序栈和链式栈、循环队列和链式队列
大秦坑王的专栏
05-16 1222
知识的学习在于点滴记录，坚持不懈；知识的学习要有深度和广度，不能只流于表面，坐井观天；知识要善于总结，不仅能够理解，更知道如何表达！ 文章目录数组和链表单链表代码实现链表逆置寻找链表倒数第K个节点判断链表是否有环，并且找出入环节点合并两个有序单链表双向链表代码实现 数组和链表 在大家接触链表之前，都大量的使用过数组，数组有‘1好2不好’，怎么解释呢？ 1好是，数组的内存是绝对连续的，因此数组的...
C++ 链表、栈、队列
weixin_40535588的博客
12-05 4824
一、C++ 链表 链表实际上是线性表的链式存储结构，与数组不同的是，它是用一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的， 且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 1.1 几种链表的介绍 1.1.1 单向链表 单向链表很容易理解，就说把指针当成一条链一样连接每一个节点，每个节点包含了一个或者多个数据。链表的存储单元不一定是连续的，长度不固定，主要用于方便实现节点的插入和删除操作。官方的话这里就不说了，作为数据结构里最基本的，感兴趣的童鞋自.
[数据结构]双链表的链式存储-双链表，链式栈，链式队列
qq_61109509的博客
03-22 3225
文章目录双链表输出双链表中各个结点的值查找双链表中第i个结点双链表结点的插入在最前面插入在双链表中某个位置插入x的结点在q所指结点的后面插入值为x的新结点在q所指结点(最后一个结点)的后面插入值为x的新结点双链表结点的删除双链表中只有唯一结点被删除的是双链表中第一个结点被删除的q是双链表中的最后一个结点被删除的结点在中间的某一个位置链式栈建立一个空的链式栈判断链式栈是否为空输出链式栈中个结点的值链式栈的插入链式栈的删除操作(出栈)链式队列建立一个空的链式队列取得链式队列的队首结点值 双链表 在链表中，每个结
1. 双向链表2. 顺序栈3. 顺序队列4. 链式队列
lllmmmll92的博客
06-04 597
链式队列功能代码：这里选择尾插头删，因为用到一个rea去存储尾节点，这样的话插入就不需要遍历了节约时间成本。
Java线性表（顺序表，链表，栈，队列）
2301_79482961的博客
06-06 1012
线性表是一种线性结构，是数据结构中的一种基本形式，用于表示一组有序的、同类型的数据元素。线性表中的元素之间构成一对一的关系，即除了第一个和最后一个元素外，每个元素都有一个前驱和一个后继。
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
动态顺序栈与动态顺序队列相似，当栈满时，可以动态扩展数组。 9. **链式栈**： 链式栈使用链表结构，通过改变头节点实现栈操作，没有容量限制的问题。 10. **二叉树**： 二叉树是每个节点最多有两个子节点的...
掌握核心数据结构：二叉树、循环队列、链表、链式栈和队列
链式队列是使用链表实现的队列结构，它保留了队列的先进先出（FIFO）特性。每个节点不仅包含数据，还有指向下一个节点的指针。在链式队列中，由于其动态的内存分配，即使在空间不足的情况下也可以插入新的元素。 5...
哈希相关的模拟实现
m0_73693552的博客
07-31 761
c++模拟实现：闭散列除留取余法的哈希表、开散列除留取余法的哈希表（vector+list）、c++STL工具unordered_map和unordered_set
数据结构：在链表中插入节点（Inserting in a Linked List）
2402_88047672的博客
08-03 761
本文讲解了在链表中插入节点的原理和实现方法。链表插入通过修改指针连接完成，相比数组更高效。插入分为三种情况：表头插入需更新头指针；中间插入需找到前驱节点并调整两个指针；尾部插入需遍历到末尾节点。文章详细分析了指针操作逻辑，并给出了C语言实现代码，包括处理边界条件（如越界检查）和内存管理。通过示例演示了如何在不同位置插入节点，最终构建出完整的链表结构。实现关键在于正确操作节点指针的指向关系。
第二十四天（数据结构：栈和队列）队列实践请看下一篇
最新发布
l2366585918的博客
08-04 257
/指向队尾元素的 插入的时候往rear的后面进行插入。//指向队头元素的 删除的时候砍掉这个头。当front == rear的时候没有办法判断这个队列是空的还满的。-> 没有变量num来对我们的元素个数来进行判断 ---- 这种是常用的。// 实际队列容纳个数为 maxnum - 1。//利用头节点来搞定stacknode的管理 对于用户来说是最友好的。//利用头节点来搞定queuenode的管理 对于用户来说是最友好的。struct ArrayQueue //同样是为了管理我们的队列的。
数据结构——查找（三、树形查找）
m0_65656149的博客
08-04 497
本文系统介绍了二叉排序树(BST)和平衡二叉树(AVL)的基本概念与操作。二叉排序树通过左小右大的特性实现高效查找(平均O(logn))，详细讲解了查找、插入、删除的递归/非递归实现，并分析了不同输入序列对树结构的影响。平衡二叉树通过平衡因子保证树高平衡，重点阐述了LL/RR/LR/RL四种旋转调整策略，以及插入删除后的平衡维护方法。文章通过代码示例展示了BST的完整实现，包括创建、遍历和节点操作，为理解和应用这两种重要数据结构提供了全面指导。
【数据结构入门】时间、空间复杂度的计算
qq_25850439的博客
07-31 828
时间复杂度的计算；空间复杂度的计算；面试OJ题*2
数据结构之顺序表应用与双指针法
LBX_0309的博客
08-01 482
摘要：本文介绍了数组元素删除的实现方法，重点分析了双指针算法在移除元素和去重问题中的应用。文章首先展示了通过元素移动实现删除的基本方法，然后详细讲解了力扣算法题"移除元素"和"删除有序数组重复项"的双指针解法，特别解释了++dst!=src条件避免无效赋值的原理。最后提出了6种优化代码性能的实用技巧，包括避免重复计算、条件判断优化、指针判空等，并以合并有序数组为例比较了不同解法的时间复杂度。
栈和队列的顺序链式存储实现及操作
链式存储的队列通常使用双向链表实现，这样可以在两端进行插入和删除操作，而无需移动其他元素，提高了效率。队列的应用场景广泛，如任务调度、打印机队列等。 通过这样的实验，学生能够深入理解栈和队列的工作原理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值