数据结构：带头结点的单链表和双链表相关操作

已于 2022-11-10 08:41:56 修改
阅读量384 收藏
点赞数 1
分类专栏： Linux C语言 文章标签： 数据结构 c语言 算法
于 2022-08-26 19:01:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jerich2213/article/details/126548931
版权

单链表（带头结点）

头结点保存链表长度和链表的第一个节点的地址，其余增删改查操作相比于不带头结点的单链表更简单。我这里用简单的学生信息系统体现增删改查操作。

  1. linklist.c

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linklist.h"

NODE *create_node(){
	NODE *p = (NODE*)malloc(sizeof(NODE));
	if(p == NULL){
		puts("Error:内存分配失败");
		exit(-1);
	}
	p->id = 0;
	p->next = NULL;
	p->score = 0;
	return p;
}
/*尾插录入*/
void create_linklist(F_NODE *const first){
	NODE *p = create_node();
	while(1){
		printf("请输入学号：");
		scanf("%d",&p->id);
		while(getchar()!='\n');
		if(linklist_search1(first,p->id) == NULL && p->id > 0){
			break;
		}
		else{
			puts("=>该学生已存在或输入有误，请重新添加");
		}
	}
	printf("请输入姓名：");
	fgets(p->name,32,stdin);
	char *find = strchr(p->name,'\n');
	if(find) *find = '\0';
	printf("请输入成绩：");
	scanf("%lf",&p->score);
	while(getchar()!='\n');
	
	if(first->next == NULL){
		first->next = p;
	}
	else{
		/*尾插*/
		NODE *find = first->next;
		while(find->next != NULL) find = find->next;
		find->next = p;
	}
	first->len++;
}
/*根据学号查找学生*/
NODE* linklist_search1(const F_NODE * first,const int stu_id){
	if(first->next == NULL){
		return NULL;
	}
	NODE *find = first->next;
	while(find != NULL){
		if(find->id == stu_id){
			return find;
		}
		find = find->next;
	}
	/*没有则查找失败*/
	return NULL;
}
/*根据姓名查找学生*/
NODE *linklist_search2(const F_NODE * first,const char *name){
	if(first->next == NULL){
		puts("=>无任何学生信息");
		return NULL;
	}
	NODE *find = first->next;
	while(find != NULL){
		if(!strcmp(find->name,name)){
			return find;
		}
		find = find->next;
	}
	/*没有则查找失败*/
	return NULL;
}
/*根据学号删除学生*/
void linklist_delete1(F_NODE *const first,const int stu_id){
	NODE *del = linklist_search1(first,stu_id); 
	if(del == NULL){
		puts("=>没有该学生");
		return;
	}
	/*头删*/
	if(del == first->next){
		first->next = del->next;
	}
	else{
		/*找到待删除节点的前一个节点*/
		NODE *find = first->next;
		while(find->next != del) find = find->next;
		find->next = del->next;
	}
	free(del);
	first->len--;		
}
/*根据姓名删除学生*/
void linklist_delete2(F_NODE *const first,const char *name){
	NODE *del = linklist_search2(first,name);
	if(del == NULL){
		puts("=>没有该学生");
		return;
	}
	/*头删*/
	if(del == first->next){
		first->next = del->next;
	}
	else{
		/*找到待删除节点的前一个节点*/
		NODE *find = first->next;
		while(find->next != del) find = find->next;
		find->next = del->next;
	}
	free(del);
	first->len--;		
}
/*修改学生信息*/
void linklist_change(NODE *const search,const int opt){
	char *find = NULL;
	switch(opt){
		case 1:
			printf("输入新的学号：");
			scanf("%d",&search->id);
			while(getchar()!='\n');
			break;
		case 2:
			printf("输入新的名字：");
			fgets(search->name,32,stdin);
			find = strchr(search->name,'\n');
			if(find) *find = '\0';
			break;
		case 3:
			printf("输入新的成绩：");
			scanf("%lf",&search->score);
			while(getchar()!='\n');
			break;
	}
}
/*显示所有学生*/
void show_list(const F_NODE *const first){
	if(first->next == NULL){
		puts("=>无任何学生信息");
		return;
	}
	else{
		NODE *p = first->next;
		puts("学号\t姓名\t成绩");
		while(p != NULL){
			printf("%.3d\t%s\t%.1lf\n",p->id,p->name,p->score);
			p = p->next;
		}
	}
	
}

  2. linklist_sort.c

    #include <stdio.h>
#include "linklist.h"
NODE *find_max(const F_NODE *const first,const int opt){
	NODE *p = first->next;
	NODE *pmax = p;
	int max_id = p->id;
	double max_score = p->score;
	switch(opt){
		case 1:
			while(p != NULL){
				if(max_id < p->id){
					max_id = p->id;
					pmax = p;
				}
				p = p->next; 
			}
			break;
		case 2:
		case 3:
			while(p != NULL){
				if(max_score < p->score){
					max_score = p->score;
					pmax = p;
				}
				p = p->next; 
			}
			break;
	}
	return pmax;
}

void move_max(F_NODE *const first,NODE *const pmax){
	if(pmax == first->next){
		first->next = pmax->next;
	}
	else{
		NODE *find = first->next;
		while(find->next != pmax) find = find->next;
		find->next = pmax->next;
	}
	pmax->next = NULL;
}
/*按学号升序或降序*/
void linklist_sort(F_NODE *const first,const int opt){
	NODE *pmax = NULL;
	NODE *head = NULL;
	NODE *tail = NULL;
	while(first->next != NULL){
		switch(opt){
			case 1:
				/*从原链表中找出最大节点地址*/
				pmax = find_max(first,opt);
				/*从链表中移出最大节点*/
				move_max(first,pmax);
				/*头插放到无头结点新链表*/
				pmax->next = head;
				head = pmax;
				break;
			case 2:
				/*从原链表中找出最大节点地址*/
				pmax = find_max(first,opt);
				/*从链表中移出最大节点*/
				move_max(first,pmax);
				/*头插放到无头结点新链表*/
				pmax->next = head;
				head = pmax;
				break;
			case 3:
				/*从原链表中找出最大节点地址*/
				pmax = find_max(first,opt);
				/*从链表中移出最大节点*/
				move_max(first,pmax);
				/*尾插放入无头结点链表*/
				if(head == NULL){
					head = pmax;
					tail = head;
				}
				else{
					tail->next = pmax;
					tail = pmax;
				}
				break;
		}
	}
	first->next = head;
}

  3. fileIO.c

    #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include "linklist.h"

void fileWrite(F_NODE *first){
	FILE *fp = fopen("./stu_info.txt","w");
	if(fp == NULL){
		perror("write");
		fclose(fp);
		exit(-1);
	}
	NODE *p = first->next;
	while(p != NULL){
			fprintf(fp,"%d\t%s\t%.1lf\n",p->id,p->name,p->score);
			p = p->next;
	}
	fclose(fp);
}
int fileRead(F_NODE *first){
	FILE *fp = fopen("./stu_info.txt","r");
	if(fp == NULL){
		perror("write");
		exit(-1);
	}
	int count = 0;
	NODE temp;
	temp.next = NULL;
	NODE *tail = NULL;
	while(EOF != fscanf(fp,"%d%s%lf",&temp.id,temp.name,&temp.score)){
		NODE *p = create_node();
		*p = temp;
		/*判断链表是否为空*/
		if(first->next == NULL){
			first->next = p;
		}
		else{
			tail->next = p; 
		}
		/*读取个数*/
		count++;
		/*尾指针指向新创建的节点*/
		tail = p;	
	}
	return count;
}
void progressBar(int n){
	/*进度条状态数组*/
	char buff[40];
	/*字符数组清零*/
	memset(buff,'\0',40);
	/*动态标签*/
	char label[] = "\\/\\/";
	for(int i = 0;i < 40;i++){
		printf("[%-39s][%c][%.1f%%]\r",buff,label[i%4],(i+1)*2.5);
		/*刷新缓冲区，先将缓冲区已有的内容打印*/
		fflush(stdout);
		buff[i] = '#';
		/*等待0.1s(100000us)刷新进度条*/
		usleep(n*500+2000);
	}
	putchar('\n');
}

  4. main.c

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "menuFrame.h"
#include "linklist.h"
#include "linklist_sort.h"
#include "fileIO.h"

int main(){
	F_NODE *first = (F_NODE*)malloc(sizeof(F_NODE));
	if(first == NULL){
		puts("Error：内存申请失败");
		exit(-1);
	}
	first->next = NULL;
	int count = fileRead(first);
	first->len = count;
	puts("=>读取中...");
	progressBar(count);
	show_list(first);
	while(1){
		mainFrame();
		int opt,flag = 1;
		int stu_id;
		char name[32],*find;
		NODE *search = NULL;
		printf("输入操作选项：");
		scanf("%d",&opt);
		while(getchar()!='\n');
		switch(opt){
			case 1:
				create_linklist(first);
				break;
			case 2:
				while(flag){
					deleteFrame();
					printf("输入选项：");
					scanf("%d",&opt);
					while(getchar()!='\n');
					switch(opt){
						case 1:
flag1:
							printf("请输入学号：");
							scanf("%d",&stu_id);
							while(getchar()!='\n');
							search = linklist_search1(first,stu_id);
							if(search == NULL){
								puts("==>学号不存在");
								goto flag1;
							}
							else{
								linklist_delete1(first,stu_id);
								puts("==>删除成功");
							}
							break;
						case 2:
flag2:
							printf("请输入姓名：");
							fgets(name,32,stdin);
							find = strchr(name,'\n');
							if(find) *find = '\0';
							search = linklist_search2(first,name);
							if(search == NULL){
								puts("==>姓名不存在");
								goto flag2;
							}
							else{
								linklist_delete2(first,name);
								puts("==>删除成功");
							}
							break;
						case 0:
							flag = 0;
							break;
						default:
							puts("==>指令错误");
							break;
					}
				}
				break;
			case 3:
				while(flag){
					printf("请输入学号：");
					scanf("%d",&stu_id);
					while(getchar()!='\n');
					search = linklist_search1(first,stu_id);
					if(search == NULL){
						puts("=>没有该学生");
						continue;
					}
					printf("该学生信息：[学号:%.3d|姓名:%s|成绩:%.1lf]\n",stu_id,search->name,search->score);
					while(flag){
						changeFrame();
						printf("请输入选项：");
						scanf("%d",&opt);
						while(getchar()!='\n');
						switch(opt){
							case 1:
								linklist_change(search,1);
								break;
							case 2:
								linklist_change(search,2);
								break;
							case 3:
								linklist_change(search,3);
								break;
							case 0:
								flag = 0;
								break;
							default:
								puts("==>指令有误");
								break;
						}
					}
					break;
				}
				break;
			case 4:
				while(flag){
					searchFrame();
					printf("输入选项：");
					scanf("%d",&opt);
					while(getchar()!='\n');
					switch(opt){
						case 1:
flag3:
							printf("请输入学号：");
							scanf("%d",&stu_id);
							while(getchar()!='\n');
							search = linklist_search1(first,stu_id);
							if(search == NULL){
								puts("==>学号不存在");
								goto flag3;
							}
							else{
								printf("该学生信息：[学号:%.3d|姓名:%s|成绩:%.1lf]\n",stu_id,search->name,search->score);
							}
							break;
						case 2:
flag4:
							printf("请输入姓名：");
							fgets(name,32,stdin);
							find = strchr(name,'\n');
							if(find) *find = '\0';
							search = linklist_search2(first,name);
							if(search == NULL){
								puts("==>姓名不存在");
								goto flag4;
							}
							else{
								printf("该学生信息：[学号:%.3d|姓名:%s|成绩:%.1lf]\n",search->id,search->name,search->score);
							}
							break;
						case 0:
							flag = 0;
							break;
						default:
							puts("==>指令错误");
							break;
					}
				}
				break;
			case 5:
				while(flag){
					showFrame();
					printf("输入选项：");
					scanf("%d",&opt);
					while(getchar()!='\n');
					switch(opt){
						case 1:
							linklist_sort(first,opt);
							show_list(first);
							break;
						case 2:
							linklist_sort(first,opt);
							show_list(first);
							break;
						case 3:
							linklist_sort(first,opt);
							show_list(first);
							break;
						case 0:
							flag = 0;
							break;
						default:
							puts("==>指令有误");
							break;
					}
				}
				break;
			case 0:
				puts("=>已退出,正在保存...");
				progressBar(first->len);
				fileWrite(first);
				return 0;
		}
	}
	return 0;
}

双向链表（带头结点）

在这里插入图片描述

  1. 头插法创建

    /*开辟内存*/
NODE *create_Node(){
	NODE *p = (NODE*)malloc(sizeof(NODE));
	if(!p){
		puts("Error:分配内存失败");
		return NULL;
		exit(-1);
	}
	p->data = 0;
	p->prev = NULL;
	p->next = NULL;
	return p;
}
/*带头结点双链表头插*/
void linklist_create(NODE *head,int data){
	NODE *p = create_Node();
	p->data = data;
	/*先连*/
	p->next = head->next;
	p->prev = head;
	/*后断*/
	if(head->next == NULL){
		head->next = p;
	}
	else{
		head->next->prev = p;
		head->next = p;
	}
	head->data++;
}

  2. 查找指定数据

    NODE *linklist_search(NODE *head,int data){
	NODE *p = head->next;
	while(p){
		if(data == p->data){
			return p;
		}
		p = p->next;
	}
	return NULL;
}

  3. 删除指定数据节点

    void linklist_delete(NODE *head){
	int data;
	printf("输入删除的数据：");
	scanf("%d",&data);
	while(getchar()!='\n');
	NODE *find = linklist_search(head,data);	
	if(find){
		find->prev->next = find->next;
		if(find->next){
			find->next->prev = find->prev;
		}
		find->next = NULL;
		find->prev = NULL;
		free(find);
		head->data--;
	}
	else{
		puts("=>删除失败");
	}
}

  4. 数据排序（升序）

    NODE *find_min(NODE *head){
	NODE *p = head->next;
	NODE *pmin = p;
	for(int i = 0;i < head->data;i++){
		if(p->data < pmin->data){
			pmin = p;
		}
		p = p->next;
	}
	head->data--;
	return pmin;
}
void move_min(NODE *head,NODE *pmin){
	pmin->prev->next = pmin->next;
	if(pmin->next){
		pmin->next->prev = pmin->prev;
	}
	pmin->prev = NULL;
	pmin->next = NULL;
}
void insert_min(NODE *head,NODE *pmin){
	NODE *find = head;
	while(find->next != NULL) find = find->next;
	find->next = pmin;
	pmin->prev = find;
}
void linklist_sort(NODE *head){
	if(!head->next){
		return;
	}
	int len = 0;
	while(head->data){
		NODE *pmin = find_min(head);
		move_min(head,pmin);
		/*尾插到原链表最后*/
		insert_min(head,pmin);
		len++;
	}
	head->data = len;
}

  5. 释放链表

    void linklist_free(NODE **head){
	if((*head)->next){
		linklist_free(&(*head)->next);
		free((*head)->next);
	}
	*head = NULL;
}
Jerich morningStar
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【大话数据结构C语言】9 双向链表
CodeAllen嵌入式
10-14 893
系列文章参考资料为《大话数据结构》，源码为个人私有，未经允许不得转载 技术交流群或资料添加微信号：CoderAllen，回复关键字即可 双向链表是在单链表的每个结点中，在设置一个指向其前驱结点的指针域 其代码表示： /*线性表的双向链表存储结构*/ typedef struct DulNode { ElemType data; struct DuLNode *prior; /*直接前驱指针*/ struct DuLNode *next; .
数据结构之单链表与双链表
guyuanxiang1995的博客
08-08 595
一、单链表中的循环链表： 目前我们的链表最后一个结点的pNext指向的是NULL；循环链表中的最后一个结点的pNext指向的是头结点； 循环链表和不是循环链表的区别：判断条件不一样！ p->pNext == NULL; p->pNext == pHeader; 二、单链表和数组的区别： 单链表的优势： 1、可以解决数组大小一旦定义之后很难改变的缺点； 2、链表中的各个
数据结构学习：有关带头结点的单向链表的常见考题（c语言）
weixin_58526281的博客
08-13 859
1.将链表中pp结点之后的结点原地逆置（反转）。 2.反向打印链表中全部的元素。 3.找出带头结点的单链表倒数第k(k>0)个结点。 4.判断单链表是否有环，并找到环的入口。 5.找出两个汇聚单链表的公共结点，如果没有汇聚，返回空，如果有，返回汇聚的第一个结点。 6.将线性表L=(a1,a2,a3,...,an-2,an-1,an)变成L=(a1,an,a2,an-1,a3,an-2,...)。数据结...
数据结构1-1，重拾链表。
xianqiuyigedao的博客
09-27 250
6-1 单链表逆转 (20分) 本题要求实现一个函数，将给定的单链表逆转。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typedef int ElementType; typedef struct Node *PtrToNode; struct Node { ElementType Data; PtrToNode Next; }; typedef PtrToNode List; List Re...
链表的改进及其应用
HHHHHHep的博客
12-18 3148
2-1 对于一非空的循环单链表，h和p分别指向链表的头、尾结点，则有：(2分) p->next == hp->next == NULLp == NULLp == h 作者: DS课程组 单位: 浙江大学 2-2 在双向循环链表结点p之后插入s的语句是： (3分) p->next=s; s->prior=p; p->nex
带头结点的双向循环链表
07-17
总结来说，带头结点的双向循环链表是一种灵活且实用的数据结构，它在C++中的实现涉及节点定义、链表操作的实现以及封装为类。理解并掌握这一数据结构对于提升编程能力，尤其是处理复杂算法问题具有重要意义。
C语言实现数据结构和双向链表操作
08-31
C语言实现数据结构和双向链表操作 本文主要介绍了C语言实现数据结构双向链表操作的相关知识点。双向链表是一种常用的数据结构，它可以从两个方向搜索某个结点，且可以从头结点和尾结点进行遍历。 1. 双向链表的...
Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】
09-21
链表的实现和操作不仅限于此，还可以扩展到更复杂的数据结构，如双向循环链表、带头结点和尾结点的链表等。通过理解和掌握链表，可以更好地理解和应用各种算法，如排序算法（如归并排序、快速排序）、查找算法（如...
带头结点双链循环线性表.rar_循环双链表
09-14
循环双链表是一种高效的数据结构，它在单链表的基础上扩展了双向链接的功能，并形成了一个首尾相连的环形结构。这种数据结构在程序设计中非常常见，特别是在处理线性序列的问题时，如动态内存分配、文件系统管理等...
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
通过深入学习和实践，你可以更好地理解和掌握双向带头循环链表，这对于理解和解决更复杂的数据结构问题以及算法设计都至关重要。同时，这也是软件开发中不可或缺的基础知识，无论是开发操作系统、数据库，还是编写...
MOOC 数据结构 第三周
weixin_46226815的博客
07-23 9697
1.与单链表相比，双链表的优点之一是（D ）。 A.插入、删除操作更简单 B.可以进行随机访问 C.可以省略表头指针或表尾指针 D.访问前后相邻节点更方便 2.带头节点的双链表L为空表时应满足（ D）。 A.L= =NULL B.L->prior= =L->next C.L->prior= =NULL D.L->next= =NULL 3.在长度为n（n≥1）的双链表中插入一个节点（非尾节点）要修改（D ）个指针域。 A.1 B.2 C.3 D.4 4.对于长度为n（n≥1）的双链表
葵花宝典之数据结构1800T--2
loverz的专栏
09-09 3783
第2章    线性表 一  选择题 1．下述哪一条是顺序存储结构的优点？（    ）【北方交通大学 2001 一、4（2分）】 A．存储密度大  B．插入运算方便  C．删除运算方便  D．可方便地用于各种逻辑结构的存储表示 2．下面关于线性表的叙述中，错误的是哪一个？（    ）【北方交通大学 2001 一、14（2分）】 A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线
【数据结构】-双链表(带头结点）
RunningSnail的博客
07-19 1538
双链表-带头结点1.头文件及类型定义2.双链表结点类型定义3.函数声明4.基本操作4.1 初始化双链表4.2 判空4.3 查找操作4.3.1 按位查找4.3.2 按值查找4.4 插入操作4.4.1指定结点插入4.4.1.1后插4.4.1.1.1 给结点4.4.1.1.2 给元素值4.4.1.2 前插4.4.2 按位插入4.5 删除操作4.6 创建双链表4.7 销毁双链表4.8 求表长4.9 遍历4.10 main函数5.小结 1.头文件及类型定义 #include<stdio.h> #inclu
线性表的链式存储结构及代码实现（单链表，双链表，循环链表）
weixin_43800761的博客
07-08 3229
  在上一篇博文中介绍了线性表的顺序存储方式，它最大的缺点就是在插入和删除操作时会移动大量的元素，这显然会耗费很多时间。后来人们便想到了用链式存储方式来解决上面这一问题。链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过 “链” 建立起数据元素之间的逻辑关系，因此插入和删除操作不需要移动元素，而只需修改指针，但也会失去顺序表可随机存取的优点。 一、单链表 1.1 单链表的定义   线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素
考研真题1：假设带有头节点的单链表
zzuli-ycz的博客
12-04 1129
假设带有头节点的单链表，节点结构如下图： 假设该链表只给出了头指针list，在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的节点（k为正整数）。若查找成功，算法输出该节点数据域的值，并返回1；否则返回0；思想如下： ...
了解数据结构中的单向链表和双向链表
不愿意透露姓名的网友
05-04 624
链表定义：将元素存放在通过连接构造起来的一系列存储块中 一、单链表 定义：每个节点两部分，即元素区elem和链接区next（指向下一个节点的地址） 第一个节点叫头结点 最后一个节点叫尾结点 尾结点的链接区指向空 # 创建一个节点类 class Node(): def __init__(self, elem, next=None): self.elem =...
《数据结构》将一个带头结点的单链表分解成两个单链表
热门推荐
千言万语ROOM
03-22 2万+
将一个带头结点的单链表分解成两个单链表 题目描述： /* 设计一个算法，将一个带头结点的单链表分解成两个具有相同结构的 链表B和C，其中B白哦的结点为A中小于0的结点，C表的结点为A中大于0 的结点， 要求B和C 仍利用A表的结点。 (A表的元素都是非0元素) */ 算法思想：‘ 假设原来的连败哦是LA，将La，分解成LB和LC，首先需要生成两个头结点，LB和LC；设置
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1513
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1228
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
带头结点的单链表和双链表
09-02
带头结点的单链表是指在链表的头部增加一个额外的结点，该结点不存储具体的数据，而是用来作为链表的头指针的前驱。这样做的好处是在进行插入和删除操作时不需要特殊处理链表为空的情况，因为头结点始终存在。 双链表是指每个结点都有两个指针，一个指向直接后继结点，一个指向直接前驱结点。这样可以方便地从任意一个结点开始访问它的前驱结点和后继结点。与单链表相比，双链表的操作更加灵活，但是相应地需要多维护一个指针域。 所以，带头结点的单链表和双链表的区别在于双链表每个结点都有指向前驱结点的指针，而带头结点的单链表只有指向后继结点的指针。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [C语言使用非循环双向链表实现队列](https://download.csdn.net/download/weixin_38704565/13757045)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [链表(一) -- 单链表与双向链表](https://blog.csdn.net/JeremyIverson/article/details/104282271)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [数据结构之单链表与双链表](https://blog.csdn.net/guyuanxiang1995/article/details/76927042)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值