双链表中有头结点 & 无头结点的各种基本操作(完整代码)

最新推荐文章于 2022-05-24 09:58:05 发布
最新推荐文章于 2022-05-24 09:58:05 发布
阅读量847 收藏 9
点赞数 1
分类专栏： 计算机技术 文章标签： 数据结构 链表 算法 c语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42071236/article/details/119186825
版权

双链表

代码是用C语言写的，但是bool类型的输出是用C++的cout写的。因为对于布尔类型，C++可以返回true或false，C只能返回1或0。

有头结点的双链表

#include<iostream>
using namespace std;
#include<malloc.h>
typedef int ElemType;
typedef struct DNode
{
	ElemType data;
	struct DNode* prior;
	struct DNode* next;
}DNode, * DLinkList;

bool InitDList(DLinkList& L) //初始化单链表
{
	L = (DNode*)malloc(sizeof(DNode)); //分配一个头结点
	if (L == NULL) return false; //内存不足，分配失败
	L->prior = NULL; //头结点的prior永远指向NULL
	L->next = NULL; //头结点之后暂时还没有结点
	return true;
}

bool DLinkListEmpty(DLinkList& L) //判断双链表是否为空表
{
	return (L->next == NULL);
}

void CreateListF(DLinkList& L) //头插法创建双链表
{
	DNode* s;
	int num;
	printf("输入：\n"); //键盘随机输入
	scanf("%d", &num);
	while (num != 999)
	{
		s = (DNode*)malloc(sizeof(DNode));
		s->data = num;
		s->next = L->next;
		if (L->next != NULL) s->next->prior = s;
		s->prior = L;
		L->next = s;
		scanf("%d", &num);
	}
}

void CreateListR(DLinkList& L) //尾插法创建单链表
{
	DNode* s, * r = L;
	for (int i = 0; i < 10; i++) //循环固定输入
	{
		s = (DNode*)malloc(sizeof(DNode));
		s->data = i;
		r->next = s;
		s->prior = r;
		r = s;
	}
	r->next = NULL;
}

void PrintDList(DLinkList& L) //输出函数
{
	DNode* p = L->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}

int DListLength(DLinkList L)
{
	DNode* p = L->next;
	int n = 0;
	while (p != NULL)
	{
		n++;
		p = p->next;
	}
	return n;
}

bool DListInsertR(DLinkList& L, int i, ElemType e)
{
	DNode* p = L, * s;
	int j = 0;
	if (i <= 0 || p->next == NULL) return false;
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false;
	else
	{
		s = (DNode*)malloc(sizeof(DNode));
		s->data = e;
		s->next = p->next;
		if (p->next != NULL)
			p->next->prior = s;
		s->prior = p;
		p->next = s;
		return true;
	}
}

bool DListInsertF(DLinkList& L, int i, ElemType e)
{
	DNode* p = L, * s;
	int j = 0;
	if (i <= 0 || p->next == NULL) return false;  //i输入错误或者双链表只有一个头结点
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false;
	else
	{
		s = (DNode*)malloc(sizeof(DNode));
		s->data = e;
		s->prior = p->prior;
		p->prior->next = s;
		s->next = p;
		p->prior = s;
		return true;
	}
}

bool DListDelete(DLinkList& L, int i, ElemType& e)
{
	DNode* p = L;
	int j = 0;
	e = -999; //删除失败时，e的值返回-999
	if (i <= 0 || p->next == NULL) return false;
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false;
	else
	{
		e = p->data;
		p->prior->next = p->next;
		if (p->next != NULL)
			p->next->prior = p->prior;
		free(p);
		return true;
	}
}

bool DListDeleteR(DLinkList& L, int i, ElemType& e)
{
	DNode* p = L, * n;
	int j = 0;
	e = -999; //删除失败时，e的值返回-999
	if (i <= 0 || p->next == NULL) return false;
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false;
	else
	{
		if (p->next == NULL) return false; //i是最后一个结点
		e = p->next->data;
		n = p->next; //i的后一个结点
		p->next = n->next;
		if (n->next != NULL) //i的后面只有最后一个结点
			n->next->prior = p;
		free(n);
		return true;
	}
}

bool DListDeleteF(DLinkList& L, int i, ElemType& e)
{
	DNode* p = L, * pre;
	int j = 0;
	e = -999; //删除失败时，e的值返回-999
	if (i <= 0 || p->next == NULL) return false;
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false;
	else
	{
		if (i == 1) return false; //i是首结点，除头结点外没有前驱结点
		pre = p->prior;
		e = pre->data;
		pre->prior->next = p;
		p->prior = pre->prior;
		free(pre);
		return true;
	}
}

bool  GetElem(DLinkList& L, int i, ElemType& e)
{
	DNode* p = L;
	int j = 0;
	e = -999; //查找失败，e返回-999
	if (i <= 0 || p == NULL) return false; //参数错误
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false; //不存在第i个位置
	else
	{
		e = p->data;
		return true;
	}
}

int  LocateElem(DLinkList& L, ElemType e)
{
	DNode* p = L->next;
	int j = 1;
	while (p != NULL && p->data != e)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return -999; //不存在第i个位置
	else  return j;
}

int main()
{
	DLinkList L;
	InitDList(L); //初始化单链表
	cout << boolalpha << "双链表现在为空吗？-" << DLinkListEmpty(L) << endl;
	printf("\n");

	CreateListR(L); //尾插法创建单链表
	cout << boolalpha << "双链表现在为空吗？-" << DLinkListEmpty(L) << endl;
	printf("\n");

	printf("双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");

	printf("双链表的长度为：%d\n\n", DListLength(L));

	ElemType num;
	int number = 2;
	printf("(按位查找)查找第%d个位置的值：\n", number);
	cout << boolalpha << "查找成功了吗？—" << GetElem(L, 2, num) << endl;
	printf("该位置的值为：%d\n\n", num);

	printf("(按元素值查找)查找值为%d的元素位置：\n", number);
	printf("该元素第一次出现的位置是：%d\n\n", LocateElem(L, 2));

	printf("在第%d个位置后插入一个结点：\n", number);
	cout << boolalpha << "插入成功了吗？-" << DListInsertR(L, 2, 8) << endl;
	printf("插入后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("插入后双链表的长度为：%d\n\n", DListLength(L));

	printf("在第%d个位置前插入一个结点：\n", number);
	cout << boolalpha << "插入成功了吗？-" << DListInsertF(L, 2, 8) << endl;
	printf("插入后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("插入后双链表的长度为：%d\n\n", DListLength(L));

	ElemType num1;
	printf("删除第%d个位置的结点：\n", number);
	cout << boolalpha << "删除成功了吗？-" << DListDelete(L, 2, num1) << endl;
	printf("删除的值为：%d\n", num1);
	printf("删除后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("删除后双链表的长度为：%d\n\n", DListLength(L));

	ElemType num2;
	printf("删除第%d个位置的后一个结点：\n", number);
	cout << boolalpha << "删除成功了吗？-" << DListDeleteR(L, 2, num2) << endl;
	printf("删除的值为：%d\n", num2);
	printf("删除后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("删除后双链表的长度为：%d\n\n", DListLength(L));

	ElemType num3;
	printf("删除第%d个位置的前一个结点：\n", number);
	cout << boolalpha << "删除成功了吗？-" << DListDeleteF(L, 2, num3) << endl;
	printf("删除的值为：%d\n", num3);
	printf("删除后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("删除后双链表的长度为：%d\n\n", DListLength(L));

	return 0;
}
  • 运行结果：
    在这里插入图片描述

无头结点的双链表

#include<iostream>
using namespace std;
#include<malloc.h>
typedef int ElemType;
typedef struct DNode
{
	ElemType data;
	struct DNode* prior;
	struct DNode* next;
}DNode, * DLinkList;

void InitDList(DLinkList& L) //初始化双链表
{
	L = NULL;
}

bool DLinkListEmpty(DLinkList& L) //判断双链表是否为空表
{
	return (L == NULL);
}

void CreateListF(DLinkList& L) //头插法创建双链表
{
	DNode* s = L, * p;
	int num;
	printf("输入：\n"); //键盘随机输入
	scanf("%d", &num);
	while (num != 999)
	{
		s = (DNode*)malloc(sizeof(DNode));
		s->data = num;
		if (L == NULL)
		{
			L = s;
			s->next = NULL;
			s->prior = NULL;
			p = s;
		}
		else
		{
			s->next = L;
			L->prior = s;
			L = s;
		}
		scanf("%d", &num);
		L->prior = NULL;
	}
}

void CreateListR(DLinkList& L) //尾插法创建双链表
{
	DNode* s, * r = L;
	for (int i = 0; i < 10; i++) //循环固定输入
	{
		s = (DNode*)malloc(sizeof(DNode));
		s->data = i;
		if (L == NULL)
		{
			L = s;
			s->next = NULL;
			s->prior = NULL;
			r = s;
		}
		else
		{
			r->next = s;
			s->prior = r;
			r = r->next;
		}
	}
	r->next = NULL;
}

void PrintDList(DLinkList& L) //输出函数
{
	DNode* p = L;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}

int DListLength(DLinkList L) //求双链表当前的长度
{
	DNode* p = L;
	int n = 0;
	while (p != NULL)
	{
		n++;
		p = p->next;
	}
	return n;
}

bool  GetElem(DLinkList& L, int i, ElemType& e) //按元素值查找
{
	DNode* p = L;
	int j = 1;
	e = -999; //查找失败，e返回-999
	if (i <= 0 || p == NULL) return false; //参数错误
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false; //不存在第i个位置
	else
	{
		e = p->data;
		return true;
	}
}

int  LocateElem(DLinkList& L, ElemType e) //按位查找
{
	DNode* p = L;
	int j = 1;
	while (p != NULL && p->data != e)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return -999; //不存在第i个位置
	else  return j;
}

bool DListInsertR(DLinkList& L, int i, ElemType e) //第i个位置后插入s结点
{
	DNode* p = L, * s;
	int j = 1;
	if (i <= 0 || p == NULL) return false;
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false;
	else
	{
		s = (DNode*)malloc(sizeof(DNode));
		s->data = e;
		s->next = p->next;
		if (p->next != NULL) //第i个结点的下一个结点为NULL
			p->next->prior = s;
		s->prior = p;
		p->next = s;
		return true;
	}
}

bool DListInsertF(DLinkList& L, int i, ElemType e) //在第i个位置前插入结点s
{
	DNode* p = L, * s;
	int j = 1;
	if (i <= 0 || p == NULL) return false;  //i输入错误或者双链表只有一个结点
	while (p != NULL && j < i) //找第i个位置
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false; //i个位置不存在
	else
	{
		s = (DNode*)malloc(sizeof(DNode)); //开辟s结点的存储空间
		s->data = e; //s结点的数据域为e的值
		if (p->prior == NULL) //i是首结点(i=1)
		{
			s->next = p; //将结点s连接到L之前
			p->prior = s;
			L = s; //L指向s结点
		}
		else //如果i不是首结点(i≠1)
		{
			s->prior = p->prior;
			p->prior->next = s;
			s->next = p;
			p->prior = s;
		}
		return true;
	}
}

bool DListDelete(DLinkList& L, int i, ElemType& e) //删除第i个位置的结点
{
	DNode* p = L, * pre;
	int j = 1;
	e = -999; //删除失败时，e的值返回-999
	if (i <= 0 || p == NULL) return false; //参数错误
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false;
	else
	{
		e = p->data;
		if (i == 1) L = p->next; //如果i是首结点(i=1),L指向p的下一个节点
		else
		{
			p->prior->next = p->next;
			if (p->next != NULL) //如果p的后一个结点为NULL
				p->next->prior = p->prior;
		}
		free(p); //释放i位置的结点
		return true;
	}
}

bool DListDeleteR(DLinkList& L, int i, ElemType& e) //删除第i个位置的后一个结点
{
	DNode* p = L, * n;
	int j = 1;
	e = -999; //删除失败时，e的值返回-999
	if (i <= 0 || p == NULL) return false;
	while (p != NULL && j < i)
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false;
	else
	{
		if (p->next == NULL) return false; //i是最后一个结点
		e = p->next->data;
		n = p->next; //i的后一个结点
		p->next = n->next;
		if (n->next != NULL) //i的后面只有最后一个结点
			n->next->prior = p;
		free(n);
		return true;
	}
}

bool DListDeleteF(DLinkList& L, int i, ElemType& e) //删除第i个位置的前一个结点
{
	DNode* p = L, * pre;
	int j = 1;
	e = -999; //删除失败时，e的值返回-999
	if (i <= 1 || p == NULL) return false; //如果i是首结点，则不存在前一个结点
	while (p != NULL && j < i) //找第i个位置
	{
		j++;
		p = p->next;
	}
	if (p == NULL) return false; //不存在第i个位置
	else
	{
		pre = p->prior; //第i个位置的前一个结点
		e = pre->data;
		if (pre->prior == NULL) L = p; //如果i=2，让L指向第二个结点
		else
		{
			pre->prior->next = p;
			p->prior = pre->prior;
		}
		free(pre); //释放结点空间
		return true;
	}
}

int main()
{
	DLinkList L;
	InitDList(L); //初始化单链表
	cout << boolalpha << "双链表现在为空吗？—" << DLinkListEmpty(L) << endl;
	printf("\n");

	CreateListF(L); //头插法创建单链表
	cout << boolalpha << "双链表现在为空吗？—" << DLinkListEmpty(L) << endl;
	printf("\n");

	printf("双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");

	printf("双链表的长度为：%d\n\n", DListLength(L));

	ElemType num;
	int number = 2;
	printf("(按位查找)查找第%d个位置的值：\n", number);
	cout << boolalpha << "查找成功了吗？—" << GetElem(L, 2, num) << endl;
	printf("该位置的值为：%d\n\n", num);

	printf("(按元素值查找)查找值为%d的元素位置：\n", number);
	printf("该元素第一次出现的位置是：%d\n\n", LocateElem(L, 2));

	printf("在第%d个位置后插入一个结点：\n", number);
	cout << boolalpha << "插入成功了吗？—" << DListInsertR(L, 2, 8) << endl;
	printf("插入后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("插入后双链表的长度为：%d\n\n", DListLength(L));

	printf("在第%d个位置前插入一个结点：\n", number);
	cout << boolalpha << "插入成功了吗？—" << DListInsertF(L, 2, 8) << endl;
	printf("插入后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("插入后双链表的长度为：%d\n\n", DListLength(L));

	ElemType num1;
	printf("删除第%d个位置的结点：\n", number);
	cout << boolalpha << "删除成功了吗？—" << DListDelete(L, 2, num1) << endl;
	printf("删除的值为：%d\n", num1);
	printf("删除后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("删除后双链表的长度为：%d\n\n", DListLength(L));

	ElemType num2;
	printf("删除第%d个位置的后一个结点：\n", number);
	cout << boolalpha << "删除成功了吗？—" << DListDeleteR(L, 2, num2) << endl;
	printf("删除的值为：%d\n", num2);
	printf("删除后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("删除后双链表的长度为：%d\n\n", DListLength(L));

	ElemType num3;
	printf("删除第%d个位置的前一个结点：\n", number);
	cout << boolalpha << "删除成功了吗？—" << DListDeleteF(L, 2, num3) << endl;
	printf("删除的值为：%d\n", num3);
	printf("删除后双链表L中的各值为：");
	PrintDList(L); //调用函数，输出单链表L
	printf("\n");
	printf("删除后双链表的长度为：%d\n\n", DListLength(L));

	return 0;
}
  • 运行结果：
    在这里插入图片描述
—Miss. Z—
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【数据结构】-双链表(带头结点）
RunningSnail的博客
07-19 1864
双链表-带头结点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
C++实现无头结点的双向链表
he_shuai20的博客
01-25 711
typedef int DataType; //实现双向链表 struct ListNode { ListNode* _next; //设置结点，指向下一节点 ListNode* _prev; //设置结点，指向上一节点 DataType _data; //设置数据结点 ListNode(const DataType& x) //将const DataType转换为List
链表之双向链表（有头and无头）
m0_48810566的博客
10-26 428
链表之双向链表 话不多说，直接看代码，你懂的！！！！！！ 无头双向链表的定义： class ListNode { public int val; public ListNode next; public ListNode prev; public ListNode(int val) { this.val = val; } } public class DoubleList { public ListNode head; public
双向链表（带头结点）
bentao1997719的博客
05-24 860
双链表 - 两个方向 带头节点 节点的定义 typedef int data_t; typedef struct link_node{ data_t data; //数据域，用来保存数据 struct link_node *next; //保存后面一个节点的地址 struct link_node *pre; //用来保存前一个节点的地址 }link_node_t; 创建带头结点的双链表 link_node_t *create_link_list(void) { //定义头结点，在堆上分配
带有头结点的双向链表
竹下客的专栏
03-14 1582
//带有头结点的双向链表 typedef int ElemType;   typedef struct DuLNode   {        ElemType data;       DuLNode *prior,*next;   }DuLNode,*DuLinkList;      //创建带有头结点的线性双向链表   void InitList(DuLinkList *L)
【C语言】带头结点双链表-基本操作
LowB_Fish的博客
03-22 190
#include<stdio.h> #include<stdlib.h> typedef struct DNode { int data; struct DNode *next,*last; //双链表每个节点带有指向下一个节点和上一个节点的指针 }DNode; DNode *Create(); DNode *Insert_Tail(DNode *D); void View_AllData(DNode *D); void View_OneData(DNode *D); vo.
C语言实现双向非循环链表（不带头结点）的基本操作
乞力马扎罗的雪CYF的博客
02-27 5427
双向链表也叫双链表，它的每个数据节点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任何一个节点开始，都可以很方便的访问它的前驱结点和后继节点。别人常常来构造双向循环链表，今天我们特立独行一下，先来尝试构造双向非循环链表。示例代码上传至  https://github.com/chenyufeng1991/DoubleLinkedList 。构造节点：typedef struct
图解无头单向非循环链表和带头双向循环链表
zhaocx111222333的博客
01-17 703
图解无头单向非循环链表和带头双向循环链表单链表(单向不带头)数据节点和头结点新增节点函数和初始化基本操作1.尾插2.尾删3.头插4.头删5.任意位置新增节点6.任意位置删除7.寻找数据8.销毁链表带头双向循环链表数据节点和头节点新增节点函数和初始化基本操作(删除和增加)1.尾插2.尾删3.头插4.头删5.在任意位置删除6.在任意位置增加 链表是一种重要的数据结构,其概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链 接次序实现的 。 这里介绍两种链表: 无头单
初始化链表的四种方法（有无头结点以及表头（尾）插入法）
日复一日，年复一年
10-02 3767
首先定义初始条件typedef struct Node{ int val; struct Node *next; }Node, *LinkedList; LinkedList HasHeadNodeIntiListAtEnd(); LinkedList HasHeadNodeIntiListAtStart(); LinkedList NoHeadNodeIntiListAtStart
无头双链表的实现
m0_62848585的博客
10-26 106
链表有单向的也有双向的 双向链表与单向链表的区别 双向链表可以存储除它自身地址外，还可以存储它的前一节点地址，也可以存储后一节点的地址。 单向链表即单链表存储除它自身地址外，只能存储下一节点的地址。 class ListNode{ public int val; public ListNode next; public ListNode prev; public ListNode(int val){ this.val = val; .
不带头结点的双向链表---C语言
颜言研的博客
09-19 3015
1、链表分为带头结点、不带头结点两种； 2、头结点的数据域不存放数据； 3、链表增加头结点的原因：使往第一个位置插入和删除元素的操作和其他位置一样； 4、常见的会考到：                     ①手写链表、                     ②实现链表的创建（插入、删除、摧毁、逆序等）操作、                     ③链表模拟栈、        ...
无头双向链表的实现
weixin_45662626的博客
02-24 269
上一篇：不带头节点的单链表的实现 无头双向链表的实现 无头双向链表就是没有头节点，每个节点都有next和前驱prev的链表。 如下图示意： 我们来开始写代码，无头双向链表的实现： class Node{ public int data; public Node next; public Node prev; public Node(int data) { this.data = data; } } public class MyLinkedList
数据结构 《3》----双向链表（带有头节点）
L.J.SHOU的专栏
01-15 4070
本文参照了 C与指针中双向链表的实现，力求简单明了。 双向链表带有一个头节点，        头节点的pre指针指向链表的最后一个node；        next指向第一个node；        val 表示链表的长度。 // copyright @ L.J.SHOU Jan.15, 2014 // double-linked-list with a head node #i
带头结点的双向链表
Yinghuhu333333的博客
02-02 1582
双向链表：每个数据节点中都有两个指针，分别指向该节点的前一个节点和后一个节点，所以在进行操作时就比较方便。在这里，我写的是带头节点的双向链表，所谓的头结点，它仅仅只是一个标志，并不保存任何数据。上面就说一个简单的双向链表。下面是我的代码：基本操作有：①双向链表的头插，尾插，头删，尾删，查找；②双向链表的任意位置之前插入元素，任意位置之后插入元素；依据元素的值进行元素的删除，依据元素的位置进行删除；...
双循环链表的基本操作（不带头结点）
minamiximawa的博客
08-10 1330
Node.h #ifndef NODE_H #define NODE_H #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;stdlib.h&amp;amp;gt; typedef struct NODE { int value; struct NODE *prior, *next; }Node, *DNode; #endif List.h ...
C++双向链表的建立（无头节点）
Jeff_Winger的博客
10-22 688
#ifndef doublychain_ #define doublychain_ #include #include #include"chainNode.h" using namespace std; template class doublychain { public: doublychain(); ~doublychain(); void insert(cons
C语言 不带头结点的双链表的实现和相关操作。
ok_阿伟的博客
07-13 1366
C语言 不带头结点的双链表的实现和相关操作。 #include<stdio.h> #include<stdlib.h> typedef int DAT; typedef struct node { struct node *prior;//指向前一节点 DAT data;//数据 struct node *next;//指向后一节点 }Node; void init_list(Node **pL)//初始化链表 { (*pL)=NULL; } Node* mack_n
无头节点双向静态链表和动态链表
菜鸟拥有不太多的知识
07-28 99
无头结点的链表
weixin_41807122的博客
03-18 418
#include "stdio.h" #include "stdlib.h" typedef struct LNode { int data; struct LNode *next; } LNode; typedef LNode* LinkedList; LinkedList create_list() { LinkedList ls = 0; LNod...
理解链表逻辑结构：头结点与无头结点的区别
**区别**：无头结点的链表在操作时需要从第一个节点开始遍历，而有头结点的链表可以直接通过头指针访问任何位置，更便于操作。无头结点的链表插入和删除节点时可能需要移动更多节点，效率较低；而有头结点的链表在...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值