C语言数据结构——链表

已于 2024-01-28 21:34:39 修改
阅读量1.8k 收藏 32
点赞数 25
分类专栏： C语言基础知识 文章标签： 数据结构 c语言 链表
于 2024-01-28 21:32:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxk2227814847/article/details/135900192
版权

（图像由AI生成） 

0.前言

在计算机科学中，数据结构是存储和组织数据的一种方式，它不仅影响数据的存储，也影响数据的检索和更新效率。C语言，作为一种经典的编程语言，提供了灵活的方式来处理数据结构，其中链表是最基本且重要的一种。

1.链表的概念及结构

1.1概念

链表（Linked List）是一种在物理上非连续、非顺序的数据结构，由一系列节点（Node）组成。链表的每个节点由两部分构成：一是存储数据元素的数据域，二是存储下一个节点地址的指针域。这种结构允许在不重新整理整个数据结构的情况下，有效地插入和删除节点。

1.2结构特点

  1. 动态存储管理：链表的大小不是在编译时确定的，而是在运行时通过申请内存来构建的，这意味着它可以根据需要动态地扩展或缩减。
  2. 节点构成：链表的每个节点通常是一个对象或结构体，包含至少两个元素：
    • 数据域：存储数据值。
    • 指针域：指向列表中下一个节点的指针。
  3. 头指针：链表通过一个外部引用（通常是一个指针）来访问，这个引用指向链表的第一个节点，称为头指针。如果链表为空，头指针指向NULL。
  4. 尾节点：链表的最后一个节点指向NULL，这标志着链表的结束。

1.3链表与数组的比较

  • 存储分配：数组在内存中占用连续空间，而链表由一系列非连续的节点组成。
  • 大小灵活性：数组的大小在定义时固定，而链表的大小可以动态变化。
  • 内存利用：链表可以更有效地管理内存，因为它只需要根据实际需要分配内存。
  • 插入和删除效率：在链表中插入或删除节点通常更快，因为不需要移动其他元素（除非是数组实现的链表）。

2.链表的分类

按照单双向性、是否循环、以及是否带头节点，链表可以被分为以下八种主要类型：

  1. 单向不循环不带头链表

    • 特点：最基本的链表形式，每个节点只有一个指向下一个节点的指针，尾节点指向NULL，不含额外的头节点。
    • 用途：简单的数据存储和遍历操作。

  2. 单向不循环带头链表

    • 特点：类似于基本的单向链表，但增加了一个不存储实际数据的头节点，头节点的指针指向第一个实际数据节点。
    • 用途：简化某些链表操作，特别是插入和删除操作。

  3. 单向循环不带头链表

    • 特点：单向链表的尾节点指向链表的第一个节点，形成一个闭环。
    • 用途：适用于需要循环访问数据的场景。

  4. 单向循环带头链表

    • 特点：单向循环链表，但有一个额外的头节点，头节点的指针指向第一个实际数据节点。
    • 用途：循环链表操作的简化，尤其在处理循环链表的起始和终止条件时。

  5. 双向不循环不带头链表

    • 特点：每个节点有两个指针，分别指向前一个和后一个节点，尾节点的后向指针指向NULL，没有头节点。
    • 用途：方便的双向遍历，易于节点的前后插入和删除。

  6. 双向不循环带头链表

    • 特点：双向链表加上一个头节点，头节点的前向指针通常指向NULL，后向指针指向第一个实际节点。
    • 用途：简化插入、删除操作，尤其是在链表头部的操作。

  7. 双向循环不带头链表

    • 特点：双向链表中的尾节点指向第一个节点，第一个节点的前向指针指向尾节点，形成一个双向闭环，不含头节点。
    • 用途：复杂的双向循环遍历，常用于需要频繁正反向操作的场景。

  8. 双向循环带头链表

    • 特点：在双向循环链表的基础上增加了头节点，头节点的前向指针指向尾节点，后向指针指向第一个实际节点。
    • 用途：在需要循环遍历的同时，简化链表头部和尾部的操作。

在深入探讨链表的不同分类后，我们将先集中讨论单链表的实现与操作。单链表，作为链表家族中最简单的成员，提供了对链表基本概念的清晰理解。我们将详细介绍单链表（单向不带头不循环链表）的实现方法和各种操作函数。

3.单链表（单向不带头不循环链表）

单链表是一种基础的数据结构，由一系列节点（Node）组成。每个节点包含一个数据域和一个指向下一个节点的指针域。

3.1单链表的实现

我们先来看一下单向不带头不循环链表的具体实现，包括3个文件：头文件SList.h、源文件SList.c和test.c.

//SList.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLTDataType;
typedef struct SListNode {
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//打印
void SLTPrint(SLTNode* phead);
//获取新节点
SLTNode* BuyNewNode(SLTDataType x);
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);
//头删
void SLTPopFront(SLTNode** pphead);
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
//在pos位置之后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos位置之后的节点
void SLTEraseAfter(SLTNode* pos);
//删除pos位置的节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//在pos位置之前插入x
void SLTInsertBefore(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//销毁
void SLTDestroy(SLTNode** pphead);



//SList.c
#define _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"

//打印
void SLTPrint(SLTNode* phead)
{
	//assert(phead);
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}
//获取新节点
SLTNode* BuyNewNode(SLTDataType x)
{
	SLTNode* pnewnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (pnewnode == NULL)
	{
		assert(0);
		return NULL;
	}
	pnewnode->data = x;
	pnewnode->next = NULL;
	return pnewnode;

}
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* pnewnode = BuyNewNode(x);
	if (*pphead == NULL)
	{
		*pphead = pnewnode;
	}
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur->next != NULL)
		{
			pcur = pcur->next;
		}
		pcur->next = pnewnode;
	}
}
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* pnewnode = BuyNewNode(x);
	if (*pphead == NULL)
	{
		*pphead = pnewnode;
	}
	else
	{
		pnewnode->next = *pphead;
		*pphead = pnewnode;
	}
}
//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* pcur = *pphead;
	//链表为空
	if (*pphead == NULL)
	{
		return;
	}
	//链表只有一个节点
	else if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//链表有多个节点
	else
	{
		while (pcur->next->next != NULL)
		{
			pcur = pcur->next;
		}
		free(pcur->next);
		pcur->next = NULL;
	}
}
//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* pcur = *pphead;
	if (pcur == NULL)
	{
		return;
	}
	else
	{
		*pphead = pcur->next;
		free(pcur);
	}
}
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没找到
	return NULL;
}
//在pos位置之后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* pnewnode = BuyNewNode(x);
	pnewnode->next = pos->next;
	pos->next = pnewnode;

}
//删除pos位置之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	SLTNode* pcur = pos->next;
	//pos之后没有节点
	if (pcur == NULL)
	{
		return;
	}
	//pos之后有节点
	else
	{
		pos->next = pcur->next;
		free(pcur);
	}
}
//删除pos位置的节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if(pos==*pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		pcur->next = pos->next;
		free(pos);
	}
}
//在pos位置之前插入x
void SLTInsertBefore(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);//链表不为空
	SLTNode* pnewnode = BuyNewNode(x);
	//pos为头节点
	if (*pphead == pos)
	{
	/*	pnewnode->next = *pphead;
		*pphead = pnewnode;*/
		SLTPushFront(pphead, x);
	}
	//pos不为头结点
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		pnewnode->next = pos;
		pcur->next = pnewnode;
	}
}
//销毁
void SLTDestroy(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		*pphead = pcur->next;
		free(pcur);
		pcur = *pphead;
	}
}



//test.c
#define _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"

void SListTest01()
{
	printf("SListTest01()\n");
	SLTNode* node1 = BuyNewNode(1);
	SLTPushBack(&node1, 2);
	SLTPushBack(&node1, 3);
	SLTPushBack(&node1, 4);
	SLTPushBack(&node1, 5);
	SLTPrint(node1);
	SLTPushFront(&node1, 0);
	SLTPrint(node1);
	SLTNode* ToFind = SLTFind(node1, 0);
	if(ToFind)
	{
		printf("Find it!\n");
	}
	else
	{
		printf("Not Find!\n");
	}
	SLTInsertAfter(ToFind, 500);
	SLTPrint(node1);
	SLTInsertBefore(&node1, ToFind, 100);
	SLTPrint(node1);
	SLTErase(&node1, ToFind);
	SLTPrint(node1);
}
void SListTest02()
{
	printf("SListTest02()\n");
	SLTNode* node1 = BuyNewNode(1);
	SLTPushBack(&node1, 2);
	SLTPushBack(&node1, 3);
	SLTPushBack(&node1, 4);
	SLTPushBack(&node1, 5);
	SLTPrint(node1);
	SLTPopBack(&node1);
	SLTPrint(node1);
	SLTPopFront(&node1);
	SLTPrint(node1);
	SLTNode* ToFind = SLTFind(node1, 3);
	SLTEraseAfter(ToFind);
	SLTPrint(node1);
	SLTDestroy(&node1);
	SLTPrint(node1);

}
int main()
{
	SListTest01();
	SListTest02();
	return 0;
}

3.2单链表函数详解

在单链表的实现中，以下是关键的数据类型定义和各个函数的实现原理与作用：

3.2.1数据类型定义

  1. typedef int SLTDataType;

    • 定义 SLTDataType 作为链表节点存储的数据类型，这里设为整型（int）。

  2. typedef struct SListNode { SLTDataType data; struct SListNode* next; } SLTNode;

    • 定义单链表的节点结构 SLTNode，包含数据（data）和指向下一个节点的指针（next）。
3.3.2函数详解

  1. 打印链表（SLTPrint）

    • 参数：头节点指针 phead。
    • 功能：遍历链表，打印每个节点的数据值。
    • 实现：使用循环遍历链表，直到遇到 NULL 结束。

  2. 获取新节点（BuyNewNode）

    • 参数：节点数据 x。
    • 功能：创建并返回一个新的链表节点。
    • 实现：分配内存，初始化数据和指针。

  3. 尾插（SLTPushBack）

    • 参数：头节点指针的指针 pphead，节点数据 x。
    • 功能：在链表尾部插入一个新节点。
    • 实现：找到链表的最后一个节点，将其 next 指向新节点。

  4. 头插（SLTPushFront）

    • 参数：头节点指针的指针 pphead，节点数据 x。
    • 功能：在链表头部插入一个新节点。
    • 实现：新节点的 next 指向原头节点，然后更新头节点。

  5. 尾删（SLTPopBack）

    • 参数：头节点指针的指针 pphead。
    • 功能：删除链表的最后一个节点。
    • 实现：找到倒数第二个节点，将其 next 设置为 NULL。

  6. 头删（SLTPopFront）

    • 参数：头节点指针的指针 pphead。
    • 功能：删除链表的第一个节点。
    • 实现：将头节点指针更新为第二个节点。

  7. 查找（SLTFind）

    • 参数：头节点指针 phead，要查找的数据 x。
    • 功能：查找链表中数据为 x 的节点。
    • 实现：遍历链表，比较节点数据。

  8. 指定位置后插入（SLTInsertAfter）

    • 参数：目标节点指针 pos，节点数据 x。
    • 功能：在指定节点之后插入新节点。
    • 实现：新节点的 next 指向 pos 的 next，然后 pos 的 next 指向新节点。

  9. 指定位置后删除（SLTEraseAfter）

    • 参数：目标节点指针 pos。
    • 功能：删除指定节点之后的节点。
    • 实现：将 pos 的 next 指向要删除节点的 next。

  10. 指定位置删除（SLTErase）

    • 参数：头节点指针的指针 pphead，要删除的节点指针 pos。
    • 功能：删除指定的节点。
    • 实现：找到 pos 的前一个节点，更新其 next 指针。

  11. 指定位置前插入（SLTInsertBefore）

    • 参数：头节点指针的指针 pphead，目标节点指针 pos，节点数据 x。
    • 功能：在指定节点之前插入新节点。
    • 实现：遍历链表找到 pos 的前一个节点，执行插入操作。

  12. 销毁链表（SLTDestroy）

    • 参数：头节点指针的指针 pphead。
    • 功能：销毁整个链表，释放所有节点。
    • 实现：遍历链表，释放每个节点的内存。
3.2.3test.c运行结果

继单链表之后，我们将转向更为复杂的双向链表。双向链表（双向带头循环链表）不仅在节点结构上比单链表复杂，其操作也更为多样。通过比较这两种链表类型，我们可以更好地理解链表作为一种数据结构的灵活性和多功能性。

4.双向链表（双向带头循环链表）

双向链表是一种常见的线性数据结构，与单链表不同，它每个节点有两个指针域，一个指向前一个节点，一个指向后一个节点，因此可以从前往后或从后往前遍历链表。本文将详细介绍双向带头循环链表的实现以及双向链表的各种常用操作函数。

4.1双向链表的实现

我们先来看一下双向带头循环链表的具体实现，包括3个文件：头文件List.h、源文件List.c和test.c.

//List.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int LTDataType;
typedef struct ListNode {
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}LTNode;

void LTPrint(LTNode* phead);//打印
void LTInit(LTNode** pphead);//初始化（通过传参）
LTNode* LTInit2();//初始化（通过返回值）
void LTDestroy(LTNode** pphead);//销毁
LTNode* BuyLTNode(LTDataType x);//创建新节点
void LTPushBack(LTNode* phead, LTDataType x);//尾插
void LTPopBack(LTNode* phead);//尾删
void LTPushFront(LTNode* phead, LTDataType x);//头插
void LTPopFront(LTNode* phead);//头删
LTNode* LTFind(LTNode* phead, LTDataType x);//查找
void LTInsertBefore(LTNode* pos, LTDataType x);//在pos位置之前插入x
void LTInsertAfter(LTNode* pos, LTDataType x);//在pos位置之后插入x
void LTRemove(LTNode* pos);//删除pos位置的节点
void LTCheckNode(LTNode* phead);//打印有效节点个数



//List.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"

//打印
void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	printf("head->");
	while(cur != phead)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
//初始化（通过传参的方式）
void LTInit(LTNode** pphead)
{
	*pphead = (LTNode*)malloc(sizeof(LTNode));
	if(*pphead == NULL)
	{
		assert(0);
		return;
	}
	(*pphead)->data = -1;
	(*pphead)->next = *pphead;
	(*pphead)->prev = *pphead;
}
//初始化（通过返回值的方式）
LTNode* LTInit2()
{
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
	if(phead == NULL)
	{
		assert(0);
		return NULL;
	}
	phead->data = -1;
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
//销毁
void LTDestroy(LTNode** pphead)
{
	LTNode* cur = (*pphead)->next;
	while(cur != *pphead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(*pphead);
	*pphead = NULL;
}
//创建新节点
LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if(newnode == NULL)
	{
		assert(0);
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* ptail = phead->prev;
	LTNode* newnode = BuyLTNode(x);
	newnode->next = phead;
	newnode->prev = ptail;
	ptail->next = newnode;
	phead->prev = newnode;
}
//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	LTNode* ptail = phead->prev;
	if(ptail == phead)
	{
		return;
	}
	LTNode* prev = ptail->prev;
	prev->next = phead;
	phead->prev = prev;
	free(ptail);
}
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyLTNode(x);
	LTNode* next = phead->next;
	newnode->next = next;
	newnode->prev = phead;
	next->prev = newnode;
	phead->next = newnode;

}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	LTNode* next = phead->next;
	if(next == phead)
	{
		return;
	}
	LTNode* nextnext = next->next;
	phead->next = nextnext;
	nextnext->prev = phead;
	free(next);

}
//查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while(cur != phead)
	{
		if(cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;

}
//在pos位置之前插入x
void LTInsertBefore(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);
	newnode->next = pos;
	newnode->prev = prev;
	prev->next = newnode;
	pos->prev = newnode;
}
//在pos位置之后插入x
void LTInsertAfter(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* next = pos->next;
	LTNode* newnode = BuyLTNode(x);
	newnode->next = next;
	newnode->prev = pos;
	next->prev = newnode;
	pos->next = newnode;
}
//删除pos位置的节点
void LTRemove(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}
//打印有效节点个数
void LTCheckNode(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	int count = 0;
	while(cur != phead)
	{
		count++;
		cur = cur->next;
	}
	printf("有效节点个数为：%d\n", count);
}



//test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
void test01()
{
	printf("test01()\n");
	LTNode* plist = NULL;
	LTInit(&plist);
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
}
void test02()
{
	printf("test02()\n");
	LTNode* plist = LTInit2();
	LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	LTPushFront(plist, 4);
	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTNode* toFind = LTFind(plist, 2);
	if (toFind)
	{
		printf("找到了\n");
	}
	else
	{
		printf("没找到\n");
	}
	LTInsertAfter(toFind, 5);
	LTInsertBefore(toFind, 6);
	LTPrint(plist);
	LTRemove(toFind);
	LTPrint(plist);
	LTCheckNode(plist);
}
int main()
{
	test01();
	test02();
	return 0;
}

4.2双向链表函数详解

4.2.1数据类型定义

在双向链表的实现中，我们使用了以下数据类型的定义：

typedef int LTDataType;
typedef struct ListNode {
    LTDataType data;
    struct ListNode* prev;
    struct ListNode* next;
} LTNode;
  • LTDataType：链表节点存储的数据类型，这里使用整数作为示例。
  • LTNode：链表节点的结构体，包含数据域 data，前驱指针 prev 和后继指针 next。这三个部分组成了链表节点的基本结构。
4.2.2 函数详解

以下是双向链表实现中的各个函数的详细介绍：

1. 初始化链表

void LTInit(LTNode** pphead);
  • 参数：头节点指针的指针 pphead。
  • 功能：初始化链表，创建一个头节点，使其 next 和 prev 指向自身，形成循环链表。这个函数用于链表的初始化操作。

2. 创建新节点

LTNode* BuyLTNode(LTDataType x);
  • 参数：节点存储的数据 x。
  • 返回值：新节点的指针。
  • 功能：创建一个新节点，为其分配内存并设置数据域为 x，前驱和后继指针为空。这个函数用于创建待插入的新节点。

3. 插入节点到尾部

void LTPushBack(LTNode* phead, LTDataType x);
  • 参数：头节点指针 phead，要插入的数据 x。
  • 功能：在双向链表的尾部插入一个新节点，更新尾节点的指针。这个函数用于在链表尾部添加新元素。

4. 删除尾部节点

void LTPopBack(LTNode* phead);
  • 参数：头节点指针 phead。
  • 功能：删除双向链表的尾部节点，更新尾节点的指针，并释放内存。这个函数用于删除链表尾部的元素。

5. 插入节点到头部

void LTPushFront(LTNode* phead, LTDataType x);
  • 参数：头节点指针 phead，要插入的数据 x。
  • 功能：在双向链表的头部插入一个新节点，更新头节点的指针。这个函数用于在链表头部添加新元素。

6. 删除头部节点

void LTPopFront(LTNode* phead);
  • 参数：头节点指针 phead。
  • 功能：删除双向链表的头部节点，更新头节点的指针，并释放内存。这个函数用于删除链表头部的元素。

7. 查找节点

LTNode* LTFind(LTNode* phead, LTDataType x);
  • 参数：头节点指针 phead，要查找的数据 x。
  • 返回值：找到的节点的指针，如果未找到则返回 NULL。
  • 功能：在双向链表中查找存储特定数据 x 的节点。这个函数用于查找链表中的元素。

8. 在指定节点之前插入新节点

void LTInsertBefore(LTNode* pos, LTDataType x);
  • 参数：要插入的位置节点 pos，要插入的数据 x。
  • 功能：在双向链表中的指定节点 pos 之前插入一个新节点，更新前驱和后继节点的指针。这个函数用于在指定位置之前

9. 在指定节点之后插入新节点

void LTInsertAfter(LTNode* pos, LTDataType x);
  • 参数：要插入的位置节点 pos，要插入的数据 x。
  • 功能：在双向链表中的指定节点 pos 之后插入一个新节点，更新前驱和后继节点的指针。这个函数用于在指定位置之后插入新元素。

10. 删除指定节点

void LTRemove(LTNode* pos);
  • 参数：要删除的节点 pos。
  • 功能：从双向链表中删除指定节点 pos，更新前驱和后继节点的指针，并释放内存。这个函数用于删除链表中的特定元素。
4.2.3test.c运行结果

5.结语

在本篇博客中，我们详细介绍了C语言中的链表数据结构，包括单向链表和双向链表。我们从链表的基本概念和结构开始，然后分别讨论了不同类型的链表，包括单向不带头不循环链表和双向带头循环链表。通过学习链表的实现和操作，我们可以更好地理解数据结构和算法的基本原理，为编程和问题解决提供强大的工具。希望本篇博客能够帮助你更深入地理解链表，并在编程中应用它们。

康熙38bdc
关注
  • 25
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
数据结构—链表（c语言）
three_points的博客
05-17 510
链表的基本操作 链是一种非常重要的数据结构，我们可以对链表进行增删改查等基本操作 #include<stdio.h> #include<stdlib.h> struct node { int num,score; struct node * next; }; void find(struct node * head)/*查找节点*/ struct node *p; int x; printf("输入要查找的学号:\n"); scanf("%d",&x); p=h
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
链表详解（附有C语言详细代码）
最新发布
Weirdo的博客
06-06 1638
在C语言中，可以使用结构体来定义链表节点。每个节点包含一个数据域（data）和一个指针域（next），其中指针域指向下一个节点。int data;// 数据域// 指针域} Node;链表作为一种重要的数据结构，具有动态分配、插入和删除操作方便等特点。通过定义节点结构、链表初始化、插入节点、删除节点和遍历链表等基本操作，可以实现链表的基本功能。此外，链表还有查找节点、反转链表、链表排序等扩展操作。链表在实际应用中具有广泛的应用场景，如文件存储、网络路由、哈希表冲突解决和LRU缓存淘汰策略等。
数据结构之链表（C语言实现）
qq_51513787的博客
04-05 1436
单链表，双向链表，循环链表（全代码）
数据结构之链表结构（C语言实现）
DataH
04-03 2051
/* ******************************************************************************** * 数据结构 * * * * 作者: zhi-...
【数据结构】链表-C语言版
局部变量和全局变量
01-17 696
顺序表缺点 顺序表随机访问很方便，但是也会有不足啊： （1）挪动数据时间开销较大：头部/中间的插入删除，需要挪动后面的所有数据，时间复杂度为O(N) （2）增容有代价：增容需要重新申请空间，拷贝数据，释放旧空间，系统消耗不小 （3）空间浪费：增容一般增至原来的2倍大空间，会有空间浪费，假如当前容量为100，满了以后增容到200，再继续插入了5个数据，后面没有插入数据了，这就浪费了95个空间。 不存在扩容代价、不存在空间浪费、按需申请空间、头部或者中间插入数据而不需要挪动数据的链表可以解决以上问
针对在校大学生的C语言入门学习——链表源码
01-26
【标题】"针对在校大学生的C语言入门学习——链表源码"，旨在为初学者提供C语言中链表数据结构的基本概念和实现方法。链表是计算机科学中一种重要的抽象数据类型，它与数组不同，不连续存储元素，而是通过指针链接...
C语言数据结构——学生选课管理系统（哈希存储结构实现）
03-12
《C语言数据结构——学生选课管理系统（哈希存储结构实现）》 本文将探讨一个基于C语言的数据结构实现——学生选课管理系统，该系统利用哈希存储结构来高效地管理大量学生和课程信息。系统的主要功能包括增加、删除...
C语言数据结构——教程
05-21
《C语言数据结构——教程》 C语言是计算机科学领域中的基础编程语言，以其高效、灵活和可移植性而闻名。在深入学习C语言的过程中，数据结构是不可或缺的一部分，它是理解算法和程序设计的关键。本教程将围绕C语言的...
C语言程序设计——职工管理系统（链表）.zip
07-13
在本项目"C语言程序设计——职工管理系统（链表）"中，主要涉及的是使用C语言进行程序设计，尤其是利用链表数据结构实现一个职工管理系统的具体应用。链表是一种非常重要的数据结构，它与数组不同，不连续存储数据，...
【数据结构篇】链表（c语言）
紫炁的博客
06-13 218
【数据结构篇】链表 设计链表 在链表类中实现这些功能： ·get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 ·addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。 ·addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。 ·addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将
数据结构（c语言）笔记---单链表
m0_65361882的博客
07-21 128
单链表
【数据结构】【C语言】 链表知识点+笔记
Mr_VK的博客
08-22 153
1. 内存4区 代码区：函数代码，存放在代码区，函数名就是这个函数的地址 全局区：全局的变量，字符串常量 栈区：系统开辟和释放 堆区：用户决定要开辟多大内存？装什么数据？使用完后还要不要继续使用？ 用户自己需要决定开辟和释放 内存示意图： #include<stdlib.h> Int *p; P=(int *)molloc(size); //在堆区开辟size个字节的内存 //指针p指向这段内存 //用molloc去开辟的内存不会自动释放，需要手动释放 Free(p)
数据结构：链表实现（c）
weixin_44525246的博客
03-05 595
链表为数据存储常用方法，以下是基于C语言实现普通单向链表。其他双向链表循环链表在此基础上做些许变化。关于是否使用表头的问题，本链表不包含表头，表头可记录链表信息，能降低使用复杂性，按需使用。 声明部分： #ifndef _LIST_H #define _LIST_H typedef int ELEMENT; //define whatever your want type enum { ERROR = 0, SUCSSE }; typedef struct {
【数据结构】链表操作C实现
cottonrose_orange的博客
09-13 460
数据类型的定义 typedef int DataType; typedef struct ListNode { DataType data; struct ListNode *next; } ListNode; 链表的初始化和销毁 链表的初始化—–&gt;构造一条空链表 链表的销毁—–&gt;销毁每个结点 //初始化 void ListInit(Li...
浅析数据结构之链表C/C++
RichardsZ_的博客
03-11 350
什么是链表？单双链表的基本操作如何实现？链表反转如何实现？
数据结构学习笔记——线性表之单链表（c语言实现）
luotuoxiansheng的博客
10-31 4997
1.概念 链式存储结构：是指把数据元素存放在任意内存未被占用的存储单元里，这组存储单元可以是连续的，也可以是不连续的。 大概就是这样： 因此，为了表示每个数据元素a1，与其直接后继数据元素 a2 之间的逻辑关系，对数据元素a来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。 对此有如下几个概念： 数据域 指针域 指针(链) 头指针 存储数据...
c语言链表结构体登陆注册
01-10
以下是一个简单的C语言链表结构体实现登陆注册的示例： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> // 定义用户结构体 typedef struct User { char username[20]; char password[20]; struct User* next; } User; // 全局变量，用于存储用户链表的头节点 User* head = NULL; // 注册函数 void registerUser(char username[], char password[]) { // 创建新用户节点 User* newUser = (User*)malloc(sizeof(User)); strcpy(newUser->username, username); strcpy(newUser->password, password); newUser->next = NULL; // 如果链表为空，将新用户节点设为头节点 if (head == NULL) { head = newUser; } else { // 遍历链表找到最后一个节点 User* current = head; while (current->next != NULL) { current = current->next; } // 将新用户节点添加到链表末尾 current->next = newUser; } printf("注册成功！n"); } // 登陆函数 void loginUser(char username[], char password[]) { // 遍历链表查找匹配的用户名和密码 User* current = head; while (current != NULL) { if (strcmp(current->username, username) == 0 && strcmp(current->password, password) == 0) { printf("登陆成功！\n"); return; } current = current->next; } printf("用户名或密码错误！\n"); } int main() { // 注册两个用户 registerUser("user1", "password1"); registerUser("user2", "password2"); // 登陆测试 loginUser("user1", "password1"); // 登陆成功 loginUser("user2", "password3"); // 用户名或密码错误 return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值