【数据结构基础_有[*pHead]和[*pEnd]的单向链表_(C语言实现)】

最新推荐文章于 2022-09-24 17:57:45 发布
最新推荐文章于 2022-09-24 17:57:45 发布
阅读量1.2k 收藏 5
点赞数 1
分类专栏： 数据结构与算法 文章标签： c语言 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sugar_wolf/article/details/121407701
版权

单向链表（含头尾指针）

本文主要是针对（含头尾指针）单向链表进行增、删、改、查操作

创建一个结构体当做节点
struct Node
{
	int iData;
	struct Node* pNext;
};

定义头尾指针

struct Node* pHead = NULL;
struct Node* pEnd = NULL;

pEnd指针是为了增加尾添加的效率，否则就要循环找尾

增加：1.尾添加

无（*pEnd）指针的尾添加

void AddToEndNopEnd(struct Node** pHead, struct Node** pEnd, int iData)
{
	//创建节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	if (NULL != pTemp)
	{
		//节点成员赋值
		pTemp->iData = iData;
		pTemp->pNext = NULL;
		//链接
		if (NULL == *pHead)
		{
			*pHead = pTemp;
		}
		else
		{
			struct Node* pt = *pHead;
			while (pt->pNext != NULL)		//找尾巴
			{
				pt = pt->pNext;
			}
			pt->pNext = pTemp;
		}
	}
}

有（*pEnd）指针的尾添加

void AddToEnd(struct Node** pHead, struct Node** pEnd, int iData)
{
	//创建节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	if (NULL != pTemp)
	{
		//节点成员赋值
		pTemp->iData = iData;
		pTemp->pNext = NULL;
		//连接链表
		if (NULL == *pHead)//空链表
		{
			*pHead = pTemp;
			//*pEnd = pTemp;
		}
		else
		{
			(*pEnd)->pNext = pTemp;
			//*pEnd = pTemp;
		}
		*pEnd = pTemp;
	}
}
增加：2.头添加
void AddToHead(struct Node** pHead, struct Node** pEnd, int iData)
{
	//创建节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	if (NULL != pTemp)
	{
		//节点成员赋值
		pTemp->iData = iData;
		pTemp->pNext = NULL;
		//连接链表
		if (NULL == *pHead)//空链表
		{
			//*pHead = pTemp;
			*pEnd = pTemp;
		}
		else
		{
			pTemp->pNext = *pHead;
			//*pHead = pTemp;
		}
		*pHead = pTemp;
	}
}

此时咱们链表的最简单的两个添加，已经完成，我们可以遍历链表来查看，并且释放链表

遍历链表
void Look(struct Node* pHead)
{
	while (pHead != NULL)
	{
		printf("%d ", pHead->iData);
		pHead = pHead->pNext;
	}
	putchar('\n');
}
释放链表
void FreeList(struct Node** pHead, struct Node** pEnd)
{
	struct Node* pTemp = *pHead;
	while (pTemp != NULL)
	{
		struct Node* pt = pTemp;
		pTemp = pTemp->pNext;
		free(pt);
	}
	*pHead = NULL;
	*pEnd = NULL;
}

释放链表记得指针要置空哈

查找：1.根据下标查询
struct Node* FindNodeByIndex(struct Node* pHead, int iIndex)
{
	//参数合法性检测
	if (NULL == pHead || iIndex < 0)
	{
		printf("链表为空/位置输入有误，无法查节点\n");
		return NULL;
	}
	//循环链表
	int i = 0;
	while (pHead != NULL)
	{
		if (i == iIndex)
			return pHead;
		i++;
		pHead = pHead->pNext;
	}
	printf("位置输入过大，无法查节点\n");
	return NULL;
}
查找：2.根据数值查询
struct Node* FindNodeByData(struct Node* pHead, int iData)
{
	//参数合法性检测
	if (NULL == pHead || iData < 0)
	{
		printf("链表为空/位置输入有误，无法查节点\n");
		return NULL;
	}
	//循环链表
	while (pHead != NULL)
	{
		if (pHead->iData == iData)
			return pHead;
		pHead = pHead->pNext;
	}
	return NULL;
}
升级版添加：1.在指定下标节点处添加节点
void InsertNodeByIndex(struct Node** pHead, struct Node** pEnd, int iIndex, int iData)
{
	//参数合法性检测
	if (iIndex < 0)
	{
		printf("下标输入有误，请重新输入\n");
		return;
	}
	//下标为0，直接头添加
	if (0 == iIndex)
	{
		AddToHead(pHead, pEnd, iData);
	}
	else
	{
		//找位置
		struct Node* pTemp = FindNodeByIndex(*pHead, iIndex - 1);
		if (pTemp != NULL)
		{
			//申请节点空间
			struct Node* pT = (struct Node*)malloc(sizeof(struct Node));
			if (pT != NULL)
			{
				//节点成员赋值
				pT->iData = iData;
				pT->pNext = NULL;
				//链接 先连后断
				pT->pNext = pTemp->pNext;
				pTemp->pNext = pT;
			}
		}
		else
		{
			printf("查无此节点");
		}
	}
}
升级版添加：2.在指定数值添加多个节点

看着很高大上，其实你只需要调用头添加即可，此时的头非彼头；

void AddSomeNode(struct Node** pHead, struct Node** pEnd, unsigned int iCount, unsigned int iData)
{
	for (unsigned int i = 0; i < iCount; i++)
	{
		AddToEnd(pHead, pEnd, iData);
	}
}
修改：1.根据数值改变此节点数据
void ChengeData(struct Node* pHead, int iResData, int iDecData)
{
	struct Node* pRec = FindNodeByData(pHead, iResData);
	if (NULL == pRec)
	{
		printf("查无此节点\n");
	}
	else
	{
		pRec->iData = iDecData;
	}
}
修改：2.根据数值改变此节点所有相同数据（一）
void ChengeSomeData(struct Node* pHead, int iResData, int iDecData)
{
	//参数合法性检测
	if (NULL == pHead)
	{
		printf("查无此节点\n");
		return;
	}
	while (pHead != NULL)
	{
		if (pHead->iData == iResData)
			pHead->iData = iDecData;
		pHead = pHead->pNext;
	}
}
修改：2.根据数值改变此节点所有相同数据（一）
void ChengeSomeDataText(struct Node* pHead, int iResData, int iDecData)
{
	//参数合法性检测
	if (NULL == pHead)
	{
		printf("查无此节点\n");
		return;
	}
	while (FindNodeByData(pHead, iResData) != NULL)
	{
		ChengeData(pHead, iResData, iDecData);
	}
}
删除：1.删除头结点
void DeleteHead(struct Node** pHead, struct Node** pEnd)
{
	//参数合法性检测
	if (NULL == pHead)
		return;
	if (*pHead == *pEnd || (*pHead)->pNext == NULL)//只有一个节点
	{
		free(*pHead);
		*pHead = NULL;
		*pEnd = NULL;
	}
	else
	{
		struct Node* pT = *pHead;
		(*pHead) = (*pHead)->pNext;
		free(pT);
	}
}
删除：2.删除尾结点
void DeleteEnd(struct Node** pHead, struct Node** pEnd)
{
	//参数合法性检测
	if (NULL == pHead)
		return;
	if (*pHead == *pEnd || (*pHead)->pNext == NULL)//只有一个节点
	{
		free(*pHead);
		*pHead = NULL;
		*pEnd = NULL;
	}
	else
	{
		//找到结尾的前一个
		struct Node* pT = *pHead;
		while (pT->pNext != *pEnd)
		{
			pT = pT->pNext;
		}
		free(*pEnd);
		*pEnd = pT;
		(*pEnd)->pNext = NULL;
	}
}
删除：3.根据数值删除此节点（只删除一个哟）
struct Node* DeleteOneDataByData(struct Node** pHead, struct Node** pEnd, int iData)
{
	if (NULL == *pHead)
		return NULL;
	if ((*pHead)->iData == iData)
	{
		DeleteHead(pHead, pEnd);
		return *pHead;
	}
	else if ((*pEnd)->iData == iData)
	{
		DeleteEnd(pHead, pEnd);
		return *pHead;
	}
	else
	{
		//循环找节点
		struct Node* pTemp = *pHead;
		while (pTemp->pNext != NULL)
		{
			if (pTemp->pNext->iData == iData)
				break;
			pTemp = pTemp->pNext;
		}
		//判断
		if (pTemp->pNext != NULL)
		{
			struct Node* pT = pTemp->pNext; //记录
			pTemp->pNext = pT->pNext;
			free(pT);
			return *pHead;   //return pTemp->pNext  ----- pHead
		}
		else
		{
			printf("查无此节点\n");
			return NULL;
		}
	}
}

提醒一点哈，这里考虑到删除的节点可能是头结点，所有采用了返回值的方式

删除：4.根据数值删除此所有相同数据的节点
void DeleteAllDataByData(struct Node** pHead, struct Node** pEnd, int iData)
{
	if (NULL == *pHead)
		return;
	struct Node* pTemp = DeleteOneDataByData(pHead, pEnd, iData);
	while (pTemp != NULL)
	{
		pTemp = DeleteOneDataByData(pHead, pEnd, iData);
	}
}
删除：5.根据下标删除此节点
void DeleteDataByIndex(struct Node** pHead, struct Node** pEnd, int iIndex)
{
	if (NULL == *pHead)
		return;
	if (0 == iIndex)
		DeleteHead(pHead, pEnd);
	else
	{
		//找前一个节点
		struct Node* pTemp = FindNodeByIndex(*pHead, iIndex - 1);
		if (pTemp != NULL)
		{
			if (pTemp->pNext == *pEnd)
				DeleteEnd(pHead, pEnd);
			//记录被删除的节点
			struct Node* pT = pTemp->pNext;
			//链接
			pTemp->pNext = pT->pNext;
			//释放
			free(pT);
		}
		else
		{
			printf("查无此节点\n");
		}
	}
}

下面是一些其他简单操作方便大家更加熟悉链表

（1）获取节点个数
int GetListNodeCount(struct Node* pHead)
{
	int iCount = 0;
	while (NULL != pHead)
	{
		iCount++;
		pHead = pHead->pNext;
	}
	return iCount;
}
（2）根据数值交换两个节点的数据
void SwapByData(struct Node* pHead, int iData1, int iData2)
{
	if (NULL == pHead)
		return;
	//查找
	struct Node* pT1 = FindNodeByData(pHead, iData1);
	struct Node* pT2 = FindNodeByData(pHead, iData2);
	//都找到才能交换
	if (pT1 != NULL && pT2 != NULL)
	{
		//交换成员
		//struct Node p = *pT1;
		//*pT1 = *pT2;
		//*pT2 = p;
		//int temp = pT1->iData;
		//pT1->iData = pT2->iData;
		//pT2->iData = temp;
		struct Node p = *pT1;
		memcpy(pT1, pT2, 4);
		memcpy(pT2, &p, 4);
	}
}
（3）根据下标交换两个节点的数据
void SwapByIndex(struct Node* pHead, int iIndex1, int iIndex2)
{
	if (NULL == pHead)
		return;
	//查找
	struct Node* pT1 = FindNodeByIndex(pHead, iIndex1);
	struct Node* pT2 = FindNodeByIndex(pHead, iIndex2);
	//都找到才能交换
	if (pT1 != NULL && pT2 != NULL)
	{
		//交换成员
		//int temp = pT1->iData;
		//pT1->iData = pT2->iData;
		//pT2->iData = temp;
		struct Node p = *pT1;
		memcpy(pT1, pT2, 4);
		memcpy(pT2, &p, 4);
	}
}
（4）交换指针指向节点
void SwapByChangePoint(struct Node** pHead, struct Node** pEnd, int iIndex1, int iIndex2)
{
	//参数合法性检测
	if (NULL == *pHead || NULL == (*pHead)->pNext || iIndex1 == iIndex2 || iIndex1 < 0 || iIndex2 < 0)
	{
		return;
	}
	//确定大小关系
	int iMin = iIndex1;
	int iMax = iIndex2;
	if (iIndex1 > iIndex2)
	{
		iMin = iIndex2;
		iMax = iIndex1;
	}
	//根据下标找节点
	struct Node* pMin = FindNodeByIndex(*pHead, iMin);
	struct Node* pMax = FindNodeByIndex(*pHead, iMax);
	//找不到就结束
	if (NULL == pMin || NULL == pMax)
	{
		printf("查无此节点\n");
		return;
	}
	//头尾交换
	if (pMin == *pHead && pMax == *pEnd)
	{
		if ((*pHead)->pNext == *pEnd)  //两个节点
		{
			(*pEnd)->pNext = *pHead;
			(*pHead)->pNext = NULL;
			//交换指向
			*pHead = *pEnd;
			*pEnd = (*pHead)->pNext;
		}
		else //多个节点
		{
			//找到尾巴的前一个节点
			struct Node* pMaxPre = FindNodeByIndex(*pHead, iMax - 1);
			//尾巴变头
			(*pEnd)->pNext = (*pHead)->pNext;
			//头变尾巴
			pMaxPre->pNext = *pHead;
			//头下一个为NULL
			(*pHead)->pNext = NULL;
			//交换指向
			*pHead = *pEnd;
			*pEnd = pMaxPre->pNext;
		}
	}
	//头和中间交换
	else if (pMin == *pHead && pMax != *pEnd)
	{
		//相邻
		if (pMin->pNext == pMax)
		{
			pMin->pNext = pMax->pNext;
			pMax->pNext = pMin;
			*pHead = pMax;
		}
		//不相邻
		else  
		{
			//找pMax的前一个指针
			struct Node* pMaxPre = FindNodeByIndex(*pHead, iMax - 1);
			//记录头的下一个节点 即链表第二个节点
			struct Node* pHeadNext = pMin->pNext;
			//头节点连在max的位置上
			pMin->pNext = pMax->pNext;
			pMaxPre->pNext = pMin;
			//pMax挪到头
			pMax->pNext = pHeadNext;
			//改变新的头
			*pHead = pMax;
		}
	}
	//尾和中间交换
	else if (pMin != *pHead && pMax == *pEnd)
	{
		if (pMin->pNext == pMax)  //相邻
		{
			//找到pMin的前一个
			struct Node* pMinPre = FindNodeByIndex(*pHead, iMin - 1);
			//先把尾巴放中间
			pMinPre->pNext = pMax;
			pMax->pNext = pMin;
			//pMin next = NULL
			pMin->pNext = NULL;
			*pEnd = pMin;
		}
		//不相邻
		else
		{
			//找到pMin的前一个
			struct Node* pMinPre = FindNodeByIndex(*pHead, iMin - 1);
			//找pMax的前一个指针
			struct Node* pMaxPre = FindNodeByIndex(*pHead, iMax - 1);
			//pmax放中间去
			pMinPre->pNext = pMax;
			pMax->pNext = pMin->pNext;
			//pMin放尾巴上去
			pMaxPre->pNext = pMin;
			pMin->pNext = NULL;
			*pEnd = pMin;
		}
	}
	//中间两个相互交换
	else if (pMin != *pHead && pMax != *pEnd)
	{
		//相邻
		if (pMin->pNext == pMax)
		{
			//找到pMin的前一个节点
			struct Node* pMinPre = FindNodeByIndex(*pHead, iMin - 1);
			struct Node* pMaxNext = pMax->pNext;
			//将pMax装在pMin 与pMinPre中间
			pMinPre->pNext = pMax;
			pMax->pNext = pMin;
			//把pMax拿下来
			pMin->pNext = pMaxNext;
		}
		//不相邻
		else
		{
			//找到pMin的前一个
			struct Node* pMinPre = FindNodeByIndex(*pHead, iMin - 1);
			struct Node* pMinNext = pMin->pNext;
			//找pMax的前一个指针
			struct Node* pMaxPre = FindNodeByIndex(*pHead, iMax - 1);
			struct Node* pMaxNext = pMax->pNext;
			//将pMin撞到pMax的位置
			pMaxPre->pNext = pMin;
			pMin->pNext = pMaxNext;
			//将pMax撞到pMin的位置
			pMinPre->pNext = pMax;
			pMax->pNext = pMinNext;
		}
	}
}
（5）根据数据翻转链表
void ReverseByData(struct Node* pHead)
{
	//参数合法性检测
	if (NULL == pHead || NULL == pHead->pNext)
	{
		return;
	}
	int iCount = GetListNodeCount(pHead);
	int i = 0, j = iCount - 1;
	for (; i < j; i++, j--)
	{
		SwapByIndex(pHead, i, j);
	}
}
（6）根据下标翻转链表
void ReverseByPoint(struct Node** pHead, struct Node** pEnd)
{
	//参数合法性检测
	if (NULL == *pHead || NULL == (*pHead)->pNext)
	{
		return;
	}
	int iCount = GetListNodeCount(*pHead);
	int i = 0, j = iCount - 1;
	for (; i < j; i++, j--)
	{
		SwapByChangePoint(pHead, pEnd, i, j);
	}
}

此时单向链表基本操作已经完成咯~

千北@
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c语言链表的尾指针,C语言单链表实现方法详解
weixin_33252145的博客
05-19 2773
本文实例讲述了C语言单链表实现方法。分享给大家供大家参考，具体如下：slist.h#ifndef __SLIST_H__#define __SLIST_H__#include#include#includetypedef int ElemType;typedef struct Node { //定义单链表中的结点信息ElemType data; //结点的数据域struct Node *next;...
C语言基础教程：单链表（尾插法）
weixin_58045538的博客
11-20 5433
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。 单链表（单向链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始，如下图所示。 本文将结合代码详解C语言链表，单向链表的数据结构可以分为两部分：数据域和指针域，数据域存储数据，指针域指向下一个储存节点的地址，C语言详细代码及注释如下。 源码展示： #include <stdio.h>
数据结构-线性表-单循环链表（使用尾指针）（c++）
m晴朗的博客
05-19 4569
目录单循环链表说明注意（一）无参构造函数（二）有参构造函数（三）析构函数（四）获取长度（五）打印数组（六）获取第i个元素的地址（七）插入 单循环链表 说明 单循环链表和单链表（参考单链表）大致一样，只是尾结点要指向头结点，本文是使用尾结点rear来表示，之所以使用尾指针，是因为如果使用头结点来寻找列表最后一个元素时间复杂度为O(n),如果使用尾结点来寻找列表最后一个元素时间复杂度为O(1) 注意 第一个元素地址表示：rear->next->next;最后一个元素地址：rear 头指针的表示，单
数据结构--单向链表实现（c语言）
qq_52360788的博客
09-14 114
因为用的是vs，所以scanf是scanf_s #include<stdio.h> #include "malloc.h" //typedef struct MyStruct *Next; struct MyStruct { int number;//保存的数据 MyStruct* next;//指向下一结构的指针 }; //创建链表的函数 MyStruct *CreateLinked() { //头指针 MyStruct* head = NULL; //尾指针 MyStr
【数据结构基础_双向链表（有[*pHead]和[*pEnd]）_(C++)】
Sugar_wolf的博客
11-29 104
此文为上一篇文章改为C++格式实现（多文件形式） 头文件 #pragma once #include<iostream> #include<cstdio> #include<cstdlib> using namespace std; struct Node { int iData; struct Node* pNext; //记录后一个节点地址 struct Node* pPre; //记录前一个节点的地址 }; class SX { private: s
数据结构与算法:单向链表实现与封装
08-26
"数据结构与算法：单向链表实现与封装" 在计算机科学中，数据结构是指计算机中...单向链表的实现与封装是数据结构和算法中的一个重要课题，通过封装，我们可以隐藏链表的实现细节，提供一个简单易用的接口供用户使用。
C语言 数据结构之链表实现代码
09-01
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和数据管理。与数组不同，链表的元素不是在连续的内存空间中存储，而是通过指针链接在一起。链表分为多种类型，如单链表、双向链表、循环链表等。本文...
C语言数据结构之双向循环链表的实例
12-31
数据结构之双向循环链表 实例代码： #include #include #include typedef struct Node{ struct Node *pNext; int data; struct Node *prior; } NODE,*PNODE; PNODE CreatList(); void TreNode(PNODE pHead); ...
双链表_链表_线性结构_数据结构与算法
02-08
这些基本操作是双链表数据结构的基础，掌握它们对于理解和实现更复杂的数据结构和算法至关重要。通过这些函数，我们可以有效地管理链表，进行增删改查，以及对链表中的数据进行排序，这些都是在实际编程中非常常见的...
c语言数组指定位置插入和删除-玩转C语言链表，单链表双向链表的建立遍历插入删除... 数组和链表.pdf
04-18
本文主要讲解了C语言中数组和链表的概念及操作，包括数组指定位置插入和删除、链表的结构、静态链表和动态链表、单链表的建立和遍历、双向链表的概念、循环链表的概念等。同时也涉及到了链表的实战应用和拓展思维。 ...
PTA7-6 C语言多项式的加法，单链表phead的两种实现
程序员早早的博客
04-09 1574
题目 C语言两种实现 仍旧跟上一篇文章说明的一样，单链表的头节点有两种实现方式，一种是头节点保存数据，另一种是头节点作为哨兵只占位，head->next才是第一个有数据的节点。 头节点保存数据 // polyA和polyB多项式相加，每个输入分别有系数和指数，以0,0结束 //相加规则，每个多项式按照指数从小到大展示，同指数的系数相加，系数为0则该项移除。 //head为第一个有数节点 #include<stdio.h> #include<stdlib.h> typedef
c语言二分法_计算机二级c语言必过攻略
weixin_39656174的博客
11-29 191
计算机二级攻略作为一个飘过二级c语言的学渣，来和还没有考过二级的小同学们分享一下二级的心得。首先，二级作为一个非专业证书，难度并不是很大。尤其是c语言，题型固定，难度适中，只要认真准备，并不需要太多时间。废话少说上题型(1)单项选择题，40 题，40 分(含公共基础知识部分 10 分)；(2)程序填空题，3 小空，18 分；(3)程序改错题，2 个错误，18 分；(4)程序设计题，24 分。知识点...
【数据结构基础_双向链表（有[*pHead]和[*pEnd]）_(C语言实现)】
Sugar_wolf的博客
11-29 747
双向链表（含头尾指针） 双向链表呢，顾名思义，就是比单向多一个向前指向节点的一个指针 本文主要是针对（含头尾指针）双向链表进行增、删、改、查操作 创建一个结构体当做节点 struct Node { int iData; struct Node* pNext; //记录后一个节点地址 struct Node* pPre; //记录前一个节点的地址 }; 前面我用的是局部定义头尾指针（每次调用都需要传参），这次咱们使用全局的 定义头尾指针 struct Node* g_pHead = NULL;
Phead 链表
m0_58629119的博客
09-24 209
#include"SList.h" void Test() { SLTNode* plist = NULL;//plist,头指针 SListPushBack(&plist,1); SListPushBack(&plist, 2); SListPushBack(&plist, 3); SListPushBack(&plist, 4); SListPrint(plist); } int main() { Test(); return 0; }
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。
weixin_58879043的博客
03-17 2152
/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode ReverseList(ListNode head) { if (head == null) { return null; ...
vb msgbox给按钮caption_【我爱学习】二级VB,C语言干货，还不戳进来！
weixin_39716800的博客
12-09 163
为了最最最特别的你，我们常建常新，常新常建你背或者不背，题库就在那里，不悲不喜你学或者不学，考试就在那里，不来不去听到这话的你是否略感扎心当当当，考前最后一波攻略，还不过来瞧瞧01基础知识1.计算机系统的主要技术指标与系统配置。2. 计算机系统、硬件、软件及其相互关系。3. 微机硬件系统的基本组成。包括:中央处理器(运算器与控制器)，内存储器(RAM与ROM)，外存储器(硬盘、软...
c++中pHead指向第一个元素，并非是一个空
MonkeyMonkeyGo
06-06 1501
pHead-&gt;val就是第一个元素值。一直困扰好久，今天测试了一下。不然老是影响写程序。
数据结构--带头结点的单链表
li94263的博客
03-02 4523
单链表分为：带头结点和不带头结点，不带头结点的单链表需要用到二级指针，容易出错。
【数据结构与算法】链表
一以贯之的努力 不得懈怠的人生
09-01 3181
数组和链表是所有数据结构的基础，链表是很重要的两种线性结构之一链表可以分为单链表、双链表、循环单链表、循环双链表四种，每一种又可以分为有头和无头两种单链表就是相邻两个节点之间只有一个指针连接，而有头单链表就是第一个节点（也就是头节点）不存储数据，后面才存储数据的链表，无头单链表就是头节点存储有数据请注意：实际运用中，有头链表是不用的至于循环单链表和循环双链表，区别就在于循环链表的尾节点会指向第一个节点。
typedef struct _MSG { char code; char name[32]; char text[128]; }msg_t; typedef struct _NODE { struct sockaddr_in clientaddr; struct _NODE *next; }node_t; int create_node(node_t **phead); void do_login(node_t *phead,int sockfd,msg_t msg,struct sockaddr_in client_addr); void do_chat(node_t *phead,int sockfd,msg_t msg,struct sockaddr_in client_addr); void do_quit(node_t *phead,int sockfd,msg_t msg,struct sockaddr_in client_addr);
最新发布
07-22
- `int create_node(node_t **phead)`：函数接受一个指向指针的参数 `phead`，用于创建一个新的链表节点，并将其添加到链表的头部。该函数返回一个整数类型的值。 - `void do_login(node_t *phead, int sockfd, msg_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

千北@

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

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

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

打赏作者

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

抵扣说明：

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

余额充值