(7)数据结构与算法-有空头链表的创建与添加

最新推荐文章于 2022-11-23 11:26:53 发布
最新推荐文章于 2022-11-23 11:26:53 发布
阅读量550 收藏 3
点赞数 2
分类专栏： 数据结构 文章标签： 链表 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_shmily_/article/details/118212047
版权

有空头链表

介绍

特点

1）第一个节点不装数据作为链表头（永远不变），从第二个节点开始有数据
2）不使用尾指针，涉及尾部，循环寻找；目的是与之前写的不一样，更有意思！
3）操作原理和操作逻辑和无空头链表基本一样，多了空头，代码部分也会稍有不同
4）与无空头链表的区别：有空头一些操作会比无空头的简单一些

链表的创建

空头的创建

	//单独创建空头链表节点
	struct Chain Head = {0，NULL};
	//或者
	struct Chain *pHead = (struct Chain*)malloc(sizeof(struct Chain));
	pHead->iData = 0;
	pHead->pNext = NULL;
	free(pHead);

上面两种创建空头的方法都可以，一样的。区别在于释放：第一种从第二个节点开始释放，第二种从头开始释放。
与struct Chain *Head区别：*Head是指针，Head是空间

节点计数器的建立

	struct Chain Head = {0,NULL};
	int iCount = 0; //计数

链表的添加

尾添加

1）传参
添加修改头本身的数据，所以要传变量头的地址；加入节点计数器，要对其进行修改，所以要传它的地址；还有要添加的数据

void AddTail(struct Chain *Head,int *iCount,int iData){}

2）参数合法性检测
头肯定要存在！NULL就是不存在；计数器不能小于0，也不能不存在

//参数合法性检测
	if (NULL == Head || NULL == iCount || *iCount < 0)
		return;

3）创建节点

struct Chain *pTemp = (struct Chain*)malloc(sizeof(struct Chain));

4）节点赋值

		pTemp->iData = iData;
		pTemp->pNext = NULL;

5）连到链表

		struct Chain*pT = Head;
		while (NULL != pT->pNext )
			pT = pT->pNext;
			//此时pT指向尾
		pT->pNext = pTemp;//连到尾

6）计数器自增

	(*iCount)++;

总代码：

void AddTail(struct Chain *Head, int *iCount, int iData)
{
	if (NULL == Head || NULL == iCount || iCount < 0)
		return;
	struct Chain *pTemp = (struct Chain*)malloc(sizeof(struct Chain));
	if (pTemp != NULL)
	{
		pTemp->iData = iData;
		pTemp->pNext = NULL;
		struct Chain*pT = Head;
		while (NULL != pT->pNext )
			pT = pT->pNext;
		pT->pNext = pTemp;
		(*iCount)++;
	}
}

释放链表

思路

改变链表和个数，就要传递链表头和个数变量，和无空头链表相似，都要进行记录当前节点，节点下移，释放节点的操作，最后不要忘了赋空

void FreeChain(struct Chain *Head, int *iCount){
	//合法性检测
	if (NULL == Head || 0 == *iCount )
		return;
	//头节点不要释放
	struct Chain *pTemp = Head->pNext ;
	if (pTemp == NULL)
		return;
	//循环释放
	while (pTemp != NULL){
		//记录当前节点
		struct Chain *pT = pTemp;
		//节点下移
		pTemp = pTemp->pNext;
		//释放节点
		free(pT );
	}
	Head->pNext  = NULL;
	*iCount = 0;
}

遍历链表

注意不要传头就行了

//这里传值也可以
void print(struct Chain *Head,int *iCount){
	if (NULL == Head)
		return;
	//定义遍历变量
	struct Chain *pTemp = Head;
	//循环遍历
	while (pTemp->pNext  != NULL){
	//跳过头节点
		printf("%d ",pTemp->pNext ->iData );
		pTemp = pTemp->pNext;
	}
	//输出记录的个数
	printf("\n共有%d个节点\n",*iCount);
}

头添加

思路:直接在头的下个位置添加；新节点连在头的下一个位置，来一个新节点就加在头后面，上一次添加的节点前：新节点连到头，头指向原来的节点断开，新节点指向原来头连的节点。

void AddHead(struct Chain*Head,int iData, int *iCount)
{
	if (NULL == Head || iCount == NULL )
		return;
	//创建
	struct Chain *pTemp = (struct Chain*)malloc(sizeof(struct Chain));
	if (pTemp == NULL)
		return;
	//赋值
	pTemp->pNext = NULL;
	pTemp->iData = iData;
	//连接
	pTemp->pNext = Head->pNext;
	Head->pNext = pTemp;
	//数量加1
	(*iCount)++;
}

中间添加

处理思路，处理逻辑基本和无空头链表类似
三种情况：

在指定的数据后面添加节点

1）传参：修改链表传一级指针（头指针不变）；传计数变量，增加节点并记录；传链表数据，要通过数据找到要添加的位置；还有要添加的数据。

void AddMid(struct Chain *pHead, int *iCount, int iData,int Data){}

2）合法性检测、循环找到链表数据的前一节点

	if (NULL == pHead || iCount == NULL || *iCount == 0)
		return;
		//定义中间变量遍历链表
	struct Chain *pT = pHead->pNext ;
	while (NULL != pT)
	{
		if (pT->iData == Data)//找到前一节点
			break;
		pT = pT->pNext;
	}
	//此时pT指向要找的前一节点

3）判断是否找到

//判断是否找到
	if (NULL == pT)
		printf("未找到\n");

4）然后就开始申请节点，节点赋值，连接节点了

	//申请节点
	struct Chain *pTemp = (struct Chain*)malloc(sizeof(struct Chain));
	if (pTemp == NULL)
		return;
	//节点赋值
	pTemp->iData = iData;
	pTemp->pNext = NULL;
	//连接
	pTemp->pNext = pT->pNext;
	pT->pNext = pTemp;
	(*iCount)++;

5）由于大链表可以说是由很多小链表组成，所以每在中间添加一个节点时，都可以说是头添加。

//传头就可，不过头节点不再是pHead,而是找的前一个节点
//这样就是头添加了
	AddHead(pT,iCount, iData);

在指定下标添加节点

和有空头的添加类似，这里就不赘叙了
（1）

void AddIndex(struct Chain *pHead, int *iCount, int iIndex, int iData)
{
	if (NULL == pHead || NULL == iCount || *iCount < 0)
		return;
	struct Chain *pTemp = (struct Chain *)malloc(sizeof(struct Chain));
	if (pTemp == NULL)
		return;
	pTemp->iData = iData;
	pTemp->pNext = NULL;
	int Sign = 0;
	struct Chain *pT = pHead;
	while (pT != NULL)
	{
		if (Sign == iIndex)
			break;
		pT = pT->pNext;
		Sign++;
	}
	 pTemp->pNext = pT->pNext ;
	 pT->pNext = pTemp;
	 (*iCount)++;
}

（2）还有一种是在有在表头添加函数的基础上建立的
这种方法在说无空头链表时讲过

//在表头添加的函数
void AddHead(struct Chain*Head,int iData, int *iCount)
{
	if (NULL == Head || iCount == NULL )
		return;
	//创建
	struct Chain *pTemp = (struct Chain*)malloc(sizeof(struct Chain));
	if (pTemp == NULL)
		return;
	//赋值
	pTemp->pNext = NULL;
	pTemp->iData = iData;
	//连接
	pTemp->pNext = Head->pNext;
	Head->pNext = pTemp;
	(*iCount)++;
}

void AddIndex(struct Chain *pHead, int *iCount, int iIndex, int iData)
{
	if (NULL == pHead || NULL == iCount || *iCount < 0)
		return;
	//找位置
	int Sign = 0;
	struct Chain *pT = pHead;
	while (pT != NULL)
	{
		if (Sign == iIndex)
			break;
		pT = pT->pNext;
		Sign++;
	}
	//此时已找到
	AddHead(pHead,iCount,iData);
}

在指定下标位置添加N个节点

上面我们已经知道在指定位置下插入一个节点的方法，那循环N次插入一个节点的函数，不就是插入N个了。
(1)最基本的方法就是直接将上面在指定下标位置添加一个节点的函数放在循环里

void MoreiData(struct Chain *pHead, int *iCount, int iIndex,int iData,int Num)
{
	int i = 1;
	while (i <= Num)
	{
		if (NULL == pHead || NULL == iCount || *iCount < 0)
			return;
		struct Chain *pTemp = (struct Chain *)malloc(sizeof(struct Chain));
		if (pTemp == NULL)
			return;
		pTemp->iData = iData;
		pTemp->pNext = NULL;
		int Sign = 0;
		struct Chain *pT = pHead;
		while (pT != NULL)
		{
			if (Sign == iIndex)
				break;
			pT = pT->pNext;
			Sign++;
		}
		pTemp->pNext = pT->pNext;
		pT->pNext = pTemp;
		(*iCount)++;
		i++;
	}
}

(2)利用在头添加的函数
在表头添加的函数如上

void MoreiData(struct Chain *pHead, int *iCount, int iIndex,int iData,int Num)
{
	int i = 1;
	while (i <= Num)
	{
		if (NULL == pHead || NULL == iCount || *iCount < 0)
			return;
		int Sign = 0;
		struct Chain *pT = pHead;
		while (pT != NULL)
		{
			if (Sign == iIndex)
				break;
			pT = pT->pNext;
			Sign++;
		}
		AddHead(pT, iCount, iData);
		i++;
	}
}
沐鑫本鑫
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++类模版：带表头链表的实现
代码信条
08-07 1263
链表的概念链表是常用的基本数据结构之一，属于线性表。同属于线性表的还有顺序表，我们常说的数组就是顺序表。 带表头链表链表的实现有带表头和不带表头两种方式。最原始的方式，也就是不带表头的实现方式，是用一个指向头结点的指针变量来记录链表的起始位置，当我们要进行插入或删除结点的操作时，必须要针对第一个结点和其它结点做出不同判断，然后用不同的代码来分别处理这两种情况。所谓带表头的实现方式，就是用一个空的结
数据结构与算法 第二章线性表笔记
weixin_46521624的博客
09-02 458
数据结构 第二章线性表笔记
有空头链表
taw19960426的博客
05-23 472
#include <stdio.h> #include <stdlib.h> //节点结构体 struct Node { int a; struct Node *pNext; } ; //头尾指针定义 struct Node *g_pHead=NULL; struct Node *g_pEnd=NULL; //空头链表初始化 void LianBiaoCh...
C语言链表之空头链表的创立，及元素的插入
m0_53036215的博客
09-15 585
#include<stdio.h> #include<stdlib.h> struct node { int num; struct node* nextptr; }; void createlisthead(struct node** headptr) { *headptr=(struct node*)malloc(sizeof(struct node)); if (*headptr != NULL) { (*headptr)->nextptr = NULL;.
数据结构链表的创建
雾的博客
05-11 4389
实现链表的创建、遍历、排序、插入、删除 。
数据结构链表创建,遍历,是否为空，求长度，插入，删除算法的演示
雍和
03-19 304
#include&lt;stdio.h&gt;#include&lt;malloc.h&gt;#include&lt;stdlib.h&gt;#include &lt;stdbool.h&gt;       /*bool类型需要的头文件*/typedef  struct  Node{    int data;/*数据域*/    struct  Node *pNext;/*指针域*/} NODE,...
数据结构学习笔记-单链表
最新发布
02-16
在所有数据结构中，链表是一种基础且重要的类型，尤其是单链表。本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下如何实现。 单链表是一种线性数据结构，其元素（节点）不是在内存中连续存储的，而是通过...
c代码-重新测试链表
07-14
在IT行业中，链表是一种基础且重要的数据结构，它在许多算法和程序设计中都扮演着关键角色。本文将深入探讨“C代码-重新测试链表”这一主题，结合提供的文件`main.c`和`README.txt`，我们将讨论C语言中的链表实现，...
c语言数据结构几个链表操作List.zip
05-14
本文将深入探讨“线性表顺序结构”和“链表”这两种数据结构，以及在C语言中如何进行操作。我们将涵盖无空头单链表和有空头单链表的基本定义、初始化、计数、插入、删除和清空链表等关键概念。 首先，线性表是一种...
数据结构链表
05-03
1. **创建链表**：链表的创建通常从一个空头节点开始，然后通过添加新的节点来构建。在C++中，我们可以使用`new`关键字动态分配内存来创建新节点。C语言中则需要手动管理内存，使用`malloc`或`calloc`函数。 2. **...
【数据结构基础_有空头单向链表_(C语言实现)】
Sugar_wolf的博客
11-29 547
有空头单向链表_(C语言实现) 本文主要是针对（含空头）单向链表进行增、删、改、查操作 创建一个结构体当做节点 struct Node { int iData; struct Node* pNext; }; 定义空头指针 //空头 struct Node stHead = { 0,NULL }; 空头不参加任何增、删， 增加：1.尾添加 此处和之前无空头链表操作只有稍微差别，咱们这次就不要尾指针了（当然你也可以尝试添加空的尾指针也是可以的），记住一定要先连后断 //尾添加 void AddT
带有空表头的创建链表的方法（下附用指针创建带有空表头的链表）
qq_41151066的博客
09-28 3172
#include<stdio.h> #include<stdlib.h> typedef struct num{ int num; struct num *next; }Num, *NUM; //创建链表 NUM createlist(NUM L,int x) { printf("开始创建链表\n"); NUM head,r,s,tail; int i=0; ...
导出空表表结构方法
weixin_34303897的博客
05-22 243
在导出数据库dmp文件时，有数据库表空记录的情况下，该空表不会被导出表结构，应用如下格式代码： select 'alter table ' || table_name || ' allocate extent(size 64k);' sql_text, table_name, tablespace_name from user_tables w...
C++ 空链表插入数据的操作
m0_46208939的博客
10-27 1761
空链表插入数据的操作前言一、那么往该链表的末尾添加一个节点的C++代码如下：二、下面是在哦链表中找到第一个含有某值的节点并删除该节点的代码：测试 前言 我们说链表是一种动态数据结构，是因为在创建链表时，无须知道链表的长度。 当插入一个节点时，我们只需要为新节点分配内存，然后调整指针的指向来确保新节点被链接到链表当中。 内存分配不是在链表创建时一次性完成的，而是每添加一个节点分配一次内存。 由于没有闲置的内存，链表的空间效率比数组高。 如果单向链表的定义如下 struct ListNode {
给链表中插入数据，中间插入法，若链表为空，则直接创建，结点不存在直接尾插，结点存在插入该结点前
weixin_61725973的博客
11-23 510
给链表中插入数据，中间插入法，若链表为空，则直接创建，结点不存在直接尾插，结点存在插入该结点前
创建链表（带头、单向、不循环）
波风水门的博客
12-30 179
第一次尝试 //这是 .h 部分的代码 #pragma once //使用这种方式来重命名数据类型，这样可以很方便的修改后续数据的数据类型，相当于#define的作用 typedef int ListType; //创建数据节点 typedef struct ListNode { ListType _date; //此处必须带上struct，因为此时还没被typedef呢 struct ListNode* _next; }ListNode; //创建头结点 typedef stru
带表头的单链表的创建、打印、 求长度、查找、插入、删除、释放
good_skills的博客
10-18 381
头文件： #define _CRT_NO_SECURE_WARNINGS #pragma once /*初始化空链表、分别通过前插法/后插法创建链表、打印、 求长度、查找、插入、删除、释放*/ #include <stdio.h> #include <stdlib.h> typedef char ElemType; typedef struct node { //链表结点 ElemType data; //结点数据域
【数据结构基础_双向循环链表（有空头）_(C语言实现)】
Sugar_wolf的博客
11-30 802
双向循环链表（含空头） 双向循环链表呢，就是将尾结点指向头结点形成一个环形 本文主要是针对双向循环链表进行增、删、改、查操作 创建一个结构体当做节点 struct Node { int iData; struct Node* pNext; struct Node* pPre; }; 定义空头 //空头 struct Node stHead; stHead.iData = 0; stHead.pNext = &stHead; stHead.pPre = &stHead;
无空头链表详解（增删改查）
taw19960426的博客
05-23 527
#include <stdio.h> #include <stdlib.h> //节点结构体 struct Node { int a; struct Node *pNext; } ; //链表的头尾指针 struct Node *g_pHead=NULL; struct Node *g_pEnd=NULL; //链表清空 需要遍历 void qingko...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

沐鑫本鑫

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

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

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

打赏作者

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

抵扣说明：

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

余额充值