数据结构与算法——有头无头循环链表详解

已于 2023-04-29 19:44:14 修改
阅读量389 收藏 7
点赞数 11
分类专栏： # 数据结构 文章标签： 数据结构 算法 链表
于 2023-01-23 23:22:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72157449/article/details/128754708
版权

在这里插入图片描述

📖作者介绍：22级树莓人（计算机专业），热爱编程＜目前在c＋＋和数据结构阶段>——目标Windows，MySQL，Qt，数据结构与算法，Linux，多线程，会持续分享学习成果和小项目的
📖作者主页：热爱编程的小K
📖专栏链接：数据结构

🎉欢迎各位→点赞👏 + 收藏💞 + 留言🔔​
💬总结：希望你看完之后，能对你有所帮助，不足请指正！共同学习交流 🐾

在这里插入图片描述

在这里插入图片描述

目录

一、循环链表的概念

对于单链表以及双向链表，其就像一个小巷，无论怎么样最终都能从一端走到另一端，然>而循环链表则像一个有传送门的小巷，因为循环链表当你以为你走到结尾的时候，其实你又回到了开头。
循环链表和非循环链表其实创建的过程以及思路几乎完全一样，唯一不同的是，非循环链>表的尾结点指向空（NULL），而循环链表的尾指针指向的是链表的开头。通过将单链表的的尾结点指向头结点的链表称之为循环单链表（Circular linkedlist）

二、有头单链表

1.准备
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef struct Node
{
	int data;
	struct Node* next;
}Node;
#define SIZE sizeof(Node)
2.创建新节点
Node* createNode(int newData)
{
	Node* newNode = (Node*)malloc(SIZE);
	assert(newNode);
	newNode->data = newData;
	newNode->next = NULL;
	return newNode;
}
3.浏览
void watchData(Node* head)
{
	if (NULL == head) return;        //防呆
	Node* curNode = head->next;
	printf("List:");
	while (curNode)
	{
		printf("%d ", curNode->data);
		curNode = curNode->next;
	}
	printf("\n");
}
4.头插

在这里插入图片描述

void push_front(Node* head, int insertData)
{
	if (NULL == head) return;
	Node* pNode = createNode(insertData);
	pNode->next = head->next;
	head->next = pNode;
}
5.尾插
void push_back(Node* head, int insertData)
{
	if (NULL == head) return;
	while (head->next) head = head->next;
	head->next = createNode(insertData);
}
6.查找

找到第pos个位置并返回地址，否则返回NULL

Node* findNode(Node* head, int pos)
{
	if (pos <= 0) return NULL;
	if (NULL == head) return NULL;
	for (int i = 0; i < pos; i++)
	{
		if (head)
			head = head->next;
		else
			return NULL;
	}
	return head;
}
7.任意插

在pos后面插入元素
在这里插入图片描述

void push_pos(Node* head, int pos, int insertData)
{
	if ( NULL == head ) return;

	Node* posNode = findNode(head, pos);  //找pos位置

	Node* pNew = createNode(insertData);
	pNew->next = posNode->next;
	posNode->next = pNew;
}
8.删除pos位置上得元素

在这里插入图片描述

void pop_pos(Node* head, int pos)
{
	if (NULL == head) return;

	Node* posNode = findNode(head, pos);     //找删除节点
	if (!posNode) return;                    //没找到

	if ( 1 == pos )                        //要删除的为第一个节点
	{
		head->next = posNode->next;
		free(posNode);
		posNode = NULL;
		return;
	}

	Node* posLift = findNode(head, pos - 1);       //找到要删除的上一个节点
	posLift->next = posNode->next;
	free(posNode);
	posNode = posLift = NULL;
}
9.修改
void modif_pos(Node* head, int pos,int modifData)
{
	if (NULL == head) return;

	Node* posNode = findNode(head,pos);
	if (!posNode) return;

	posNode->data = modifData;
}
10.求表长
int listLenth(Node* head)
{
	int Lenth = 0;
	while (head->next)
	{
		Lenth++;
		head = head->next;
	}
	return Lenth;
}
11.判表空
bool empty_List(Node* head)
{
	if ( head->next == NULL )
	{
		return true;
	}
	return false;
}
12.测试代码
int main()
{
	Node* List = NULL;
	Node* pHead = createNode(0);
	List = pHead;
	printf("%s\n", empty_List(List) ? "true" : "false");
	for (int i = 0; i < 11; i++)
	{
		push_back(List,i+1);
	}
	watchData(List);
	push_front(List,99);
	watchData(List);
	//printf("%d", findNode(List, 4)->data);
	push_pos(List, 5, 11);
	watchData(List);
	pop_pos(List, 5);
	watchData(List);
	modif_pos(List, 1, 88);
	watchData(List);
	printf("%d", listLenth(List));
	printf("\n%s\n", empty_List(List) ? "true" : "false");
	return 0;
}

在这里插入图片描述

13.综合代码
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef struct Node
{
	int data;
	struct Node* next;
}Node;

#define SIZE sizeof(Node)

//创建新节点
Node* createNode(int newData);
//浏览
void watchData(Node* head);
//头插
void push_front(Node* head,int insertData);
//尾插
void push_back(Node* head, int insertData);
//找到第pos个位置并返回地址，否则返回NULL
Node* findNode(Node* head, int pos);
//在pos后面插入元素
void push_pos(Node* head, int pos, int insertData);
//删除pos位置上得元素
void pop_pos(Node* head, int pos);
//修改
void modif_pos(Node* head, int pos,int modifData);
//求表长
int listLenth(Node* head);
//判断表是否为空
bool empty_List(Node* head);

int main()
{
	Node* List = NULL;
	Node* pHead = createNode(0);
	List = pHead;
	printf("%s\n", empty_List(List) ? "true" : "false");
	for (int i = 0; i < 11; i++)
	{
		push_back(List,i+1);
	}
	watchData(List);
	push_front(List,99);
	watchData(List);
	//printf("%d", findNode(List, 4)->data);
	push_pos(List, 5, 11);
	watchData(List);
	pop_pos(List, 5);
	watchData(List);
	modif_pos(List, 1, 88);
	watchData(List);
	printf("%d", listLenth(List));
	printf("\n%s\n", empty_List(List) ? "true" : "false");
	return 0;
}



Node* createNode(int newData)
{
	Node* newNode = (Node*)malloc(SIZE);
	assert(newNode);
	newNode->data = newData;
	newNode->next = NULL;
	return newNode;
}

void watchData(Node* head)
{
	if (NULL == head) return;        //防呆
	Node* curNode = head->next;
	printf("List:");
	while (curNode)
	{
		printf("%d ", curNode->data);
		curNode = curNode->next;
	}
	printf("\n");
}

void push_front(Node* head, int insertData)
{
	if (NULL == head) return;
	Node* pNode = createNode(insertData);
	pNode->next = head->next;
	head->next = pNode;
}

void push_back(Node* head, int insertData)
{
	if (NULL == head) return;
	while (head->next) head = head->next;
	head->next = createNode(insertData);
}

Node* findNode(Node* head, int pos)
{
	if (pos <= 0) return NULL;
	if (NULL == head) return NULL;
	for (int i = 0; i < pos; i++)
	{
		if (head)
			head = head->next;
		else
			return NULL;
	}
	return head;
}

void push_pos(Node* head, int pos, int insertData)
{
	if ( NULL == head ) return;

	Node* posNode = findNode(head, pos);  //找pos位置

	Node* pNew = createNode(insertData);
	pNew->next = posNode->next;
	posNode->next = pNew;
}

void pop_pos(Node* head, int pos)
{
	if (NULL == head) return;

	Node* posNode = findNode(head, pos);     //找删除节点
	if (!posNode) return;                    //没找到

	if ( 1 == pos )                        //要删除的为第一个节点
	{
		head->next = posNode->next;
		free(posNode);
		posNode = NULL;
		return;
	}

	Node* posLift = findNode(head, pos - 1);       //找到要删除的上一个节点
	posLift->next = posNode->next;
	free(posNode);
	posNode = posLift = NULL;
}

void modif_pos(Node* head, int pos,int modifData)
{
	if (NULL == head) return;

	Node* posNode = findNode(head,pos);
	if (!posNode) return;

	posNode->data = modifData;
}

int listLenth(Node* head)
{
	int Lenth = 0;
	while (head->next)
	{
		Lenth++;
		head = head->next;
	}
	return Lenth;
}

bool empty_List(Node* head)
{
	if ( head->next == NULL )
	{
		return true;
	}
	return false;
}

三、无头单链表

  • 无头单链表，即不含有头结点的单项链表
  • 与有头单链表原理一样，但是要注意对于头结点的插入和删除要变更头结点
  • 在面向过程编程时，需要注意函数参数应为二级指针
综合代码
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef struct Node
{
	int data;
	struct Node* next;
}Node;

#define SIZE sizeof(Node)

//创建新节点
Node* createNode(int newData);
//浏览
void watchData(Node* head);
//头插
void push_front(Node** head, int insertData);
//尾插
void push_back(Node** head, int insertData);
//找到第pos个位置并返回地址，否则返回NULL
Node* findNode(Node* head, int pos);
//在pos后面插入元素
void push_pos(Node** head, int pos, int insertData);
//删除pos位置上得元素
void pop_pos(Node** head, int pos);
//修改
void modif_pos(Node* head, int pos, int modifData);
//求表长
int listLenth(Node* head);
//判断表是否为空
bool empty_List(Node* head);

int main()
{
	Node* List = NULL;  //创建链表
	for (int i = 0; i < 11; i++)
	{
		push_front(&List, i);
	}
	watchData(List);
	push_back(&List, 9999);
	watchData(List);
	push_pos(&List, 5, 6666);
	watchData(List);
	pop_pos(&List, 4);
	watchData(List);
	modif_pos(List, 7, 8888);
	watchData(List);
	printf("%d ", listLenth(List));
	printf("\n%s", empty_List(List) ? "true" : "false");
	return 0;
}



Node* createNode(int newData)
{
	//1 申请内存
	Node* newNode = (Node*)malloc(SIZE);
	assert(newNode);
	//2 数据赋值
	newNode->data = newData;
	newNode->next = NULL;
	//3 返回
	return newNode;
}

void watchData(Node* head)
{
	printf("List:");
	while (head)
	{
		printf("%d ", head->data);
		//切换到下一个节点
		head = head->next;
	}
	printf("\n");
}

void push_front(Node** head, int insertData)
{
	//1 防呆
	if (NULL == head) return;
	Node* pNode = createNode(insertData);
	//2 新节点的next指针指向原来的第一个结点
	pNode->next = *head;
	//3 新节点成为第一个节点
	*head = pNode;
}

void push_back(Node** head, int insertData)
{
	//1 防呆
	if (NULL == head) return;
	Node* pNode = *head;
	Node* newNode = createNode(insertData);
	if ( *head )//*head为真，非空链表
	{
		//找到最后一个
		while ( pNode->next ) pNode = pNode->next;
		pNode->next = newNode;
	}
	else //空链表
	{
		*head = newNode;
	}
}

Node* findNode(Node* head, int pos)
{
	if (pos <= 0) return NULL;
	if (NULL == head) return NULL;
	for (int i = 1; i < pos; i++)
	{
		if (head)
			head = head->next;
		else
			return NULL;
	}
	return head;
}

void push_pos(Node** head, int pos, int insertData)
{
	if (NULL == head) return;
	Node* pNew = createNode(insertData);
	if ( 0 == pos )     //相当于头插
	{
		pNew->next = *head;
		*head = pNew;
		return;
	}
	Node* posNode = findNode(*head, pos);    //找pos位置
	if (NULL == posNode) return;            //找不到，直接返回
	//posNode的下一个节点成为新节点的下一个节点
	pNew->next = posNode->next;
	//新节点成为posNode的下一个节点
	posNode->next = pNew;
}

void pop_pos(Node** head, int pos)
{
	if (NULL == head) return;

	Node* posNode = findNode(*head, pos);     //找删除节点
	if (!posNode) return;                     //没找到

	if (1 == pos)                        //要删除的为第一个节点
	{
		//第二个成为新的头结点
		(*head) = (*head)->next;
		//释放节点
		free(posNode);
		posNode = NULL;
		return;
	}
	Node* posLift = findNode(*head, pos - 1);       //找到要删除的上一个节点
	//posLift的next指针指向posNode的下一个节点
	posLift->next = posNode->next;
	//释放第pos个节点的内存
	free(posNode);
	//忘掉解除占用内存段的地址
	posNode = posLift = NULL;
}

void modif_pos(Node* head, int pos, int modifData)
{
	if (NULL == head) return;

	Node* posNode = findNode(head, pos);
	if (!posNode) return;

	posNode->data = modifData;
}

int listLenth(Node* head)
{
	int Lenth = 0;
	while (head)
	{
		Lenth++;
		head = head->next;
	}
	return Lenth;
}

bool empty_List(Node* head)
{
	if (head->next == NULL)
	{
		return true;
	}
	return false;
}

四、无头循环单链表

在这里插入图片描述

  • 最后一个节点的next指针指向第一个节点
  • 效率提高了一点，可以从前往后查找，也可以从后往前查找
综合代码
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef struct Node
{
	int data;
	struct Node* next;
}Node;

#define SIZE sizeof(Node)

//创建新节点
Node* createNode(int newData);
//浏览
void watchData(Node* head);
//头插
void push_front(Node** head, int insertData);
//尾插
void push_back(Node** head, int insertData);
//找到第pos个位置并返回地址，否则返回NULL
Node* findNode(Node* head, int pos);
//在pos后面插入元素
void push_pos(Node** head, int pos, int insertData);
//删除pos位置上得元素
void pop_pos(Node** head, int pos);
//修改
void modif_pos(Node* head, int pos, int modifData);
//求表长
int listLenth(Node* head);
//判断表是否为空
bool empty_List(Node* head);
//找最后一个节点
Node* findtailNode(Node** head);

int main()
{
	Node* List = NULL;  //创建链表
	for (int i = 0; i < 12; i++)
	{
		push_back(&List, i);
	}
	watchData(List);
	push_front(&List, 999);
	watchData(List);
	//printf("%d ", findNode(List, 1)->data);
	push_pos(&List, 13, 2222);
	watchData(List);
	pop_pos(&List, 1);
	watchData(List);
	pop_pos(&List, 13);
	watchData(List);
	modif_pos(List, 5, 777);
	watchData(List);
	printf("%d ", listLenth(List));
	printf("\n%s", empty_List(List) ? "true" : "false");
	return 0;
}



Node* createNode(int newData)
{
	//1 申请内存
	Node* newNode = (Node*)malloc(SIZE);
	assert(newNode);
	//2 数据赋值
	newNode->data = newData;
	newNode->next = NULL;
	//3 返回
	return newNode;
}

void watchData(Node* head)
{
	printf("List:");
	if (NULL != head)
	{
		Node* pTemp = head;
		while (1)
		{
			printf("%d ", pTemp->data);
			if (pTemp->next == head)   break;    //pTemp是最后一个节点
			pTemp = pTemp->next;                 //切换到下一个节点
		}
	}
	printf("\n");
}

void push_front(Node** head, int insertData)
{
	//1 防呆
	if (NULL == head) return;
	Node* pNode = createNode(insertData);
	//2 找到尾结点
	Node* tailNode = findtailNode(head);
	//3 新节点的next指针指向原来的第一个结点
	pNode->next = *head;
	//4 新节点成为第一个节点
	*head = pNode;
	//5 tailNode的next指针指向第一个节点
	tailNode->next = *head;
}

void push_back(Node** head, int insertData)
{
	//1 防呆
	if (NULL == head) return;
	Node* newNode = createNode(insertData);
	if (*head)//*head为真，非空链表
	{
		//找到最后一个
		Node* pNode = findtailNode(head);
		newNode->next = *head; //新节点的next指针指向头,newNode->next = pNode->next;
		pNode->next = newNode; //新节点成为原来的尾节点的下一个节点
	}
	else //空链表
	{
		//顺序不能地颠倒，*head为空
		*head = newNode;         //新节点成为头结点
		newNode->next = *head;   //新节点的next指针指向头结点
	}
}

Node* findNode(Node* head, int pos)
{
	if (pos <= 0) return NULL;
	if (NULL == head) return NULL;
	Node* pTemp = head;
	for (int i = 1; i < pos; i++)
	{
		if (pTemp->next == head) return NULL;
		else pTemp = pTemp->next;
	}
	return pTemp;
}

void push_pos(Node** head, int pos, int insertData)
{
	if (NULL == head) return;
	Node* pNew = createNode(insertData);
	Node* tailNode = findtailNode(head);
	if (0 == pos)     //相当于头插
	{
		pNew->next = *head;
		*head = pNew;
		tailNode->next = pNew;
		return;
	}
	Node* posNode = findNode(*head, pos);    //找pos位置
	if (NULL == posNode) return;             //找不到，直接返回
	//posNode的下一个节点成为新节点的下一个节点
	pNew->next = posNode->next;
	//新节点成为posNode的下一个节点
	posNode->next = pNew;
}

void pop_pos(Node** head, int pos)
{
	if (NULL == head) return;

	Node* pHead = *head;
	Node* posNode = findNode(*head, pos);     //找删除节点
	if (!posNode) return;                     //没找到

	//找尾结点
	Node* tailNode = findtailNode(head);
	if ( NULL == tailNode )
	{
		printf("pop_pos中tailNode没有找到 %d", __LINE__); 
		return;
	}

	if (1 == pos)                        //要删除的为第一个节点
	{
		if ( posNode->next == pHead )   //链表中就一个节点
		{
			free(*head);
			*head = NULL;
		}
		else
		{
			//让第二个节点成为新的头结点
			*head = pHead->next;
			//尾结点的下一个指向头结点
			tailNode->next = *head;
			free(pHead);
			pHead = NULL;
		}
		return;
	}

	Node* posLift = findNode(*head, pos - 1);       //找到要删除的上一个节点
	//posLift的next指针指向posNode的下一个节点
	posLift->next = posNode->next;
	//释放第pos个节点的内存
	free(posNode);
	//忘掉解除占用内存段的地址
	posNode = posLift = NULL;
}

void modif_pos(Node* head, int pos, int modifData)
{
	if (NULL == head) return;

	Node* posNode = findNode(head, pos);
	if (!posNode) return;

	posNode->data = modifData;
}

int listLenth(Node* head)
{
	int Lenth = 0;
	Node* pTemp = head;
	while (1)
	{
		Lenth++;
		if (pTemp->next == head) break;
		pTemp = pTemp->next;
	}
	return Lenth;
}

bool empty_List(Node* head)
{
	if (head->next == head)
	{
		return true;
	}
	return false;
}

Node* findtailNode(Node** head)
{
	if (NULL == head)return NULL;
	Node* pTemp = *head;
	while (1)
	{
		if (pTemp->next == *head)return pTemp;
		pTemp = pTemp->next;
	}
}
xiaok-cpp
关注
  • 11
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
c语言单链表：有头结点和无头结两种列表的区别以及创建和输出的区别
weixin_44347833的博客
03-29 2006
链表的结点类型定义： struct student{ //定义学生结构类型 ElemType length; //记录链表长度 int num; //学号 int score; //分数 struct student *next; ...
数据结构与算法——>单向循环链表
papaxiong1的博客
09-19 706
继上一篇单项链表后（https://blog.csdn.net/papaxiong1/article/details/100906397） 我们发现，对于单链表，由于每个结点只存储了向后的指针，到了尾指针就停止了向后的操作，这样当中某一结点就无法找到它的前驱结点了，无法回头！ 定义 将单链表中尾结点的指针从指向NUll指向头结点（或第一个元素结点），使得整个链表形成一个环，这种头尾相接的单链...
链表-----单向链表详解
weixin_51134816的博客
05-04 1444
玩单链表的时候一定要注意区分头指针和头结点，在链表的初阶学习时，老师可能会对第一个结点直接取地址传过去，在无头单链表中，头指针和第一个结点重名，这就导致了当时学链表的时候很疑惑为啥一会儿传第一个结点的地址，一会儿传第一个结点的地址的地址。菜就多练！
数据结构（二）——单向有头链表的原理以及简单应用
weixin_44463519的博客
11-07 675
这一章主要叙述了有头单链表的原理和增删改查的应用。
无头链表和有头链表的区别
Faded0104的博客
08-15 1392
无头链表和有头链表的区别 一点吐槽。 做了很多单链表的题目，看到网上有很多无头链表的题目，就一直很疑惑，无头？链表怎么可以无头？？然后百度了下，如上面的博文中解释。但是我还是有点不服气，明明还是有头的呀，区别不过是第一个节点有没有存放数据的区别好嘛。谁先把这种两边叫无头链表的？？（真误人子弟哎） 不过我第一次自己写链表的时候真的有点疑惑第一个节点到底是存不存数据呢？后来想了想，还是存了数据。结果我一直写的是无头链表的。 ...
【数据结构】无头和有头单链表基本操作的实现与比较（C语言）
weixin_42263122的博客
12-27 409
typedef int DataType; typedef struct SListNode{//结点 struct SListNode* next; DataType data; }SListNode,*PListNode; int main(){ PListNode Phead; } 区别： （1）尾插操作：因为如果链表为空，无头链表需要对头指针Phead进行赋值所以传参时，需要...
算法和数据结构总结---循环链表
Kroner的博客
11-28 672
前言： 循环链表不同于单向链表和双向链表，它比起前两者具有更高的灵活性，和单向链表和双向链表不同，循环链表不用担心遍历到链表的尾巴而无法进行遍历下去。循环链表的最后一个元素不是指向NULL而是指向头部，这样的逻辑结构使得循环链表的每一个元素既可以看为头结点也可以看为尾结点，下图为循环链表的主要两种类型。 双向链表接口的公共接口 void clist_init(DList*list,void (...
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
Python实现数据结构与算法——反转链表
12-21
反转链表是数据结构与算法领域中的一个经典问题，它要求我们改变链表节点的指向，使得原本顺着一个方向的链表变成逆序。在这个问题中，我们可以采用两种方法来解决：迭代和递归。 首先，让我们详细讲解迭代的解题...
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
单链表的两种简单实现（有头节点和无头节点）
12-09
重学数据结构第一步：简单实现下链表，功能不是很完善，重在学习思想。
数据结构与算法 c语言 线性表-静态链表
最新发布
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
有头结点和无头结点链表
香蕉皮榨西瓜汁 的博客
08-23 1650
头结点概念  首先，单链表是由表头指针所唯一确定的，因此，单链表可以用头指针的名字来命名，若头指针名为 L，则称该链表为表 L  首元结点是指链表中存储第一个数据元素的结点  头结点是在首元结点之前设的一个结点，其 next 指针指向首元结点，其据域可以不存储任何信息。  但头指针永远指向的是链表中第一个结点的指针，有头结点则指向头结点，无则指向首元结点。头指针不可变，要遍历链表应另设结点指针  增加了头结点后，首元结点的地址保存在头结点的指针域中，则对链表的第一个数据元素的操作（插入、删除）与其他的数据
有头结点和没有头结点的单链表
qq_63133045的博客
04-24 2191
在我们遇到的大多数题中，一般都是有头结点的单链表。这里我们可以把没有头结点的单链表看成我们的特殊情况，接下来，我们将从有头结点的单链表和没有头结点的单链表的定义，插入一个元素，删除一个元素等方面进行对比。 有头结点的单链表和没有头结点的单链表的定义： typedef int ElemType; typedef struct LNode { ElemType data; struct LNode* next; }LNode,*LinkList; 带头结点的单链表的按位插入 bool ListI
无头节点单链表和有头节点单链表
CrazyQiQi的博客
09-15 2341
无头结点和有头节点 无头结点：第一个节点既有数据域又有指针域。 但是通过一个 pHead 指针指向和标记第一个节点 有头节点：在第一个节点之前加入一个头节点，头节点的 data 域可以设置表长等相关信息，但也可以不设置。头节点的指针域指向第一个节点。 引入头节点的优势 对第一个位置元素的操作（添加、删除）更加方便 若使用头结点，则第1个位置的插入和删除都是对p—>next进行操作，...
C++ 无/有表头节点单链表——头插法
qq_62015542的博客
03-26 2914
单链表头插法的算法
数据结构之有头链表的实现
qq_46282869的博客
07-23 196
有头链表实现与理论，重在实现，含源代码和测试代码，可为学习数据结构的小伙伴们提供参考。
单链表有头节点与无头结点的区别
热门推荐
weixin_46273997的博客
02-15 1万+
1.先区分一下概念： 头结点： 在单链表第一个元素结点之前设置的一个结点，数据域可以不存任何信息，指针域指向单链表第一个元素的结点。对于单链表来说，头结点可有可无，但为了操作方便，一般情况下单链表都具有头结点，后面的分析将会区别一下有头结点和没有头结点的区别。 优点：减少了单链表添加删除时特殊情况的判断，减少了程序的复杂性，主要是添加和删除在第一个有元素的结点（首元结点）上有区别，如果链表没有头...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xiaok-cpp

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值