《链表：结构、优势、类型及操作实现》

最新推荐文章于 2025-07-14 00:00:41 发布
最新推荐文章于 2025-07-14 00:00:41 发布
阅读量1.2k 收藏 20
点赞数 37
CC 4.0 BY-SA版权
文章标签： 链表 数据结构 算法 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/biubiubiuplusplu/article/details/149290057

文章目录

《链表：详解其结构、优势及适用场景》

什么是链表？

链表是一种线性数据结构，由一系列节点（Node）组成，每个节点包含两部分：

  • 数据域：存储节点的数据（如整数、字符串等）。

  • 指针域：存储下一个节点的地址（或引用），通过指针将节点串联成链状结构。

链表的第一个节点称为头节点（Head），最后一个节点的指针域为null（表示链表结束）。

链表的结构（以单链表为例）

// C语言单链表节点定义
struct Node {
	int data;          		// 数据域
	struct Node* next; 		// 指针域（指向下一节点的首地址）
};

链表的核心优势

1. 动态扩容，无需预分配内存

  • 数组需要预先指定大小（如int arr[100]），若数据量超过大小需重新分配内存并复制元素，效率低。

  • 链表的节点在运行时动态创建，只需为新节点分配内存并调整指针，无需预先定义容量，内存利用率更高。

2. 插入 / 删除操作高效（时间复杂度 O (1)）

  • 数组中插入 / 删除元素时，需移动目标位置后的所有元素（如在数组第i位插入元素，需移动n-i个元素），时间复杂度为O(n)。

  • 链表中插入 / 删除元素时，只需修改相邻节点的指针，无需移动其他元素，时间复杂度为O(1)（前提是已找到目标节点位置）。

3. 内存利用率高，避免空间浪费

  • 数组可能存在空间浪费（如定义了大小为 100 的数组，实际只用了 10 个元素）。

  • 链表的节点数量与数据量严格匹配，每新增一个数据才分配一个节点的内存，几乎无空间浪费。

4. 灵活的结构扩展
  • 链表可轻松扩展为双向链表（每个节点增加prev指针，支持双向遍历）、循环链表（尾节点指向头节点，适合环形结构场景）、链表树 / 图（如二叉树的节点本质是双向链表的扩展）等，适应更多复杂场景。

链表 vs 数组：核心差异总结

特性 链表 数组
内存分配 动态分配，非连续 静态分配（或预分配），连续
容量 无固定容量，动态增长 固定容量，超容需扩容
访问效率 按顺序访问（O (n)） 随机访问（O (1)）
插入 / 删除效率 已知位置时 O (1) O (n)（需移动元素）
内存利用率 高（按需分配） 可能浪费（预分配过剩）

适合链表的场景

  • 频繁进行插入 / 删除操作的场景（如链表式队列、栈）。

  • 数据量不确定，需动态扩容的场景（如日志记录、动态列表）。

  • 内存碎片化严重，无法分配连续大内存的场景。

例如：操作系统的进程调度链表、Java 的 LinkedList、Python 的列表（底层部分逻辑类似链表）等。

常见链表封装

有头链表

第一个节点不储存数据，好处：基本不需要考虑传参的问题

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

//创建节点的函数
struct Node* creatListNode(int data);

//往链表中添加节点

//尾插
void push_back(struct Node* pHead, int data);

//中间插入
//插入成为第pos个节点
void insertByPos(struct Node* pHead, int pos,int insertData);
//遍历
void travel(struct Node* head);

//找链表中数据为 findData的节点并返回其地址 找不到返回NULL
struct Node* findNodeByData(struct Node* pHead, int findData);
//找链表中第pos个节点并返回其地址 找不到返回NULL
struct Node* findNodeByPos(struct Node* pHead, int pos);

//修改
bool modifyNodeByPos(struct Node* pHead, int pos, int modifyData);
bool modifyNodeByData(struct Node* pHead, int findData, int modifyData);

//删除
//删除pHead链表中第pos个节点
bool deleteNodeByPos(struct Node* pHead, int pos);
//删除pHead链表中为delData的数据
bool deleteNodeByData(struct Node* pHead, int delData);
//头插
void push_front(struct Node* pHead, int data);

//遍历链表
void travel(Node* pHead);
int main() {

	Node* list = creatListNode(999);
	for (int i = 0; i < 10; i++){
		push_back(list, i);
		travel(list);
	}
	int n;
	Node* p;
	while (1) {
		/*
		printf("请输入要查的数:");
		scanf_s("%d", &n);
		p=findNodeByPos(list, n);
		if (p) {
			printf("%d\n", p->data);
		}
		else {
			printf("找不到\n");
		}*/
		printf("删第几个:");
		scanf_s("%d", &n);
		//bool isfind = deleteNodeByPos(list, n);
		//bool isModify = modifyNodeByPos(list, n, 999);
		insertByPos(list, n, 888);
		travel(list);
	}
	return 0;
}
void travel(Node* pHead) {
	if (NULL == pHead) {
		return;
	}
	Node* pTemp = pHead->next;
	printf("list:");
	while (1){
		if (pTemp == NULL)	break;
		printf("%d ", pTemp->data);
		pTemp = pTemp->next;
	}
	printf("\n");
}
//创建节点
Node* creatListNode(int data) {
	Node* pNew = (Node*)malloc(sizeof(Node));
	assert(pNew);
	pNew->data = data;
	pNew->next = NULL;
	return pNew;
}
void push_back(Node* pHead, int data) {
	if (NULL == pHead)	return;
	Node* p = pHead;
	while (1) {
		if (p->next == NULL)	break;
		p = p->next;
	}
	p->next = creatListNode(data);
}
//找链表中数据为 findData的节点并返回其地址 找不到返回NULL
struct Node* findNodeByData(struct Node* pHead, int findData) {
	if (NULL == pHead)	return NULL;
	Node* p = pHead->next;
	while (1){
		if (p == NULL) break;
		if (p->data == findData)	return p;
		p = p->next;
	}
	return NULL;
}
//找链表中第pos个节点并返回其地址 找不到返回NULL
struct Node* findNodeByPos(struct Node* pHead, int pos) {
	if (NULL == pHead) return NULL;
	if (pos < 1)	return NULL;
	for (int i = 0; i < pos; i++){
		pHead = pHead->next;
		if (NULL == pHead)	break;
	}
	return pHead;
}
//删除pHead链表中第pos个节点
bool deleteNodeByPos(struct Node* pHead, int pos) {
	if (pos < 1)	return false;
	Node* p = findNodeByPos(pHead, pos);
	if (!p)	return false;
	if (pos == 1) {
		pHead->next = p->next;
		free(p);
		return true;
	}
	else {
		pHead = findNodeByPos(pHead, pos - 1);
	}
	pHead->next = p->next;
	free(p);
	return true;
}
//修改
bool modifyNodeByPos(struct Node* pHead, int pos, int modifyData) {
	Node* p = findNodeByPos(pHead, pos);
	if (p) {
		p->data = modifyData;
		return true;
	}
	return false;
}
bool modifyNodeByData(struct Node* pHead, int findData, int modifyData) {
	Node* p = findNodeByData(pHead, findData);
	if (p) {
		p->data = modifyData;
		return true;
	}
	return false;
}
//插入成为第pos个节点
void insertByPos(struct Node* pHead, int pos, int insertData) {
	if (pos < 1)	return;
	if (NULL == pHead)	return;
	Node* p = NULL;
	if (pos == 1) {
		p = pHead;
	}
	else {
		p = findNodeByPos(pHead, pos - 1);
		if (p == NULL) {
			push_back(pHead,insertData);
			return;
		}
	}
	Node* pNode = creatListNode(insertData);
	pNode->next = p->next;
	p->next = pNode;
}
//删除pHead链表中为delData的数据
bool deleteNodeByData(struct Node* pHead, int delData) {
	if (NULL == pHead)	return false;
	Node* p = findNodeByData(pHead, delData);
	if (NULL == p)	return false;
	Node* pTemp = pHead;
	while (1) {
		if (pTemp == NULL)	break;
		if (pTemp->next == p) {
			pTemp->next = p->next;
			free(p);
			return true;
		}
		pTemp = pTemp->next;
	}
	return false;
}
//头插
void push_front(struct Node* pHead, int data) {
	if (pHead == NULL)	return;
	Node* p = creatListNode(data);
	p->next = pHead->next;
	pHead->next = p;
}

无头链表

需要改变第一个节点的时候需要传入二级指针改变指针的指向

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

//创建节点的函数
struct Node* creatListNode(int data);

//往链表中添加节点

//尾插
void push_back(struct Node** pHead, int data);

//中间插入
//插入成为第pos个节点
void insertByPos(struct Node** pHead, int pos, int insertData);
//遍历
void travel(struct Node* head);

//找链表中数据为 findData的节点并返回其地址 找不到返回NULL
struct Node* findNodeByData(struct Node* pHead, int findData);
//找链表中第pos个节点并返回其地址 找不到返回NULL
struct Node* findNodeByPos(struct Node* pHead, int pos);

//修改
bool modifyNodeByPos(struct Node* pHead, int pos, int modifyData);
bool modifyNodeByData(struct Node* pHead, int findData, int modifyData);

//删除
//删除pHead链表中第pos个节点
bool deleteNodeByPos(struct Node** pHead, int pos);
//删除pHead链表中为delData的数据
bool deleteNodeByData(struct Node** pHead, int delData);
//头插
void push_front(struct Node** pHead, int data);



void travel(Node* pHead) {
	if (NULL == pHead) {
		return;
	}
	Node* pTemp = pHead;
	printf("list:");
	while (1) {
		if (pTemp == NULL)	break;
		printf("%d ", pTemp->data);
		pTemp = pTemp->next;
	}
	printf("\n");
}

int main() {

	Node* list= NULL;
	push_front(&list, 99);
	travel(list);
	return 0;
}
//创建节点
Node* creatListNode(int data) {
	Node* pNew = (Node*)malloc(sizeof(Node));
	assert(pNew);
	pNew->data = data;
	pNew->next = NULL;
	return pNew;
}
void push_back(Node** pHead, int data) {
	if (NULL == pHead)	return;
	if (NULL == *pHead) {
		*pHead = creatListNode(data);
		return;
	}
	Node* p = *pHead;
	while (1) {
		if (p->next == NULL)	break;
		p = p->next;
	}
	p->next = creatListNode(data);
}
//找链表中数据为 findData的节点并返回其地址 找不到返回NULL
struct Node* findNodeByData(struct Node* pHead, int findData) {
	if (NULL == pHead)	return NULL;
	Node* p = pHead->next;
	while (1) {
		if (p == NULL) break;
		if (p->data == findData)	return p;
		p = p->next;
	}
	return NULL;
}
//找链表中第pos个节点并返回其地址 找不到返回NULL
struct Node* findNodeByPos(struct Node* pHead, int pos) {
	if (NULL == pHead) return NULL;
	if (pos < 1)	return NULL;
	for (int i = 0; i < pos-1; i++) {
		pHead = pHead->next;
		if (NULL == pHead)	break;
	}
	return pHead;
}
//删除pHead链表中第pos个节点
bool deleteNodeByPos(struct Node** pHead, int pos) {
	if (pos < 1)	return false;
	if (*pHead == NULL)	return false;
	Node* p = findNodeByPos(*pHead, pos);
	Node* pTemp = NULL;
	if (NULL==p)	return false;
	if (pos == 1) {
		pTemp = *pHead;
		*pHead = (*pHead)->next;
		free(pTemp);
		return true;
	}
	else {
		pTemp = findNodeByPos(*pHead, pos - 1);
	}
	pTemp->next = p->next;
	free(p);
	return true;
}
//修改
bool modifyNodeByPos(struct Node* pHead, int pos, int modifyData) {
	Node* p = findNodeByPos(pHead, pos);
	if (p) {
		p->data = modifyData;
		return true;
	}
	return false;
}
bool modifyNodeByData(struct Node* pHead, int findData, int modifyData) {
	Node* p = findNodeByData(pHead, findData);
	if (p) {
		p->data = modifyData;
		return true;
	}
	return false;
}
//插入成为第pos个节点
void insertByPos(struct Node** pHead, int pos, int insertData) {
	if (pos < 1)	return;
	if (NULL == pHead)	return;
	Node* p = NULL;
	Node* pNode = creatListNode(insertData);
	if (pos == 1) {
		pNode->next = *pHead;
		*pHead = pNode;
		return;
	}
	else {
		p = findNodeByPos(*pHead, pos - 1);
		if (p == NULL) {
			push_back(pHead, insertData);
			return;
		}
	}
	pNode->next = p->next;
	p->next = pNode;
}
//删除pHead链表中为delData的数据
bool deleteNodeByData(struct Node** pHead, int delData) {
	if (NULL == pHead)	return false;
	if (*pHead == NULL)	return false;
	Node* p = NULL;
	if ((*pHead)->data == delData) {
		p = *pHead;
		*pHead = (*pHead)->next;
		free(p);
		return true;
	}
	p = findNodeByData(*pHead, delData);
	if (NULL == p)	return false;
	Node* pTemp = *pHead;
	while (1) {
		if (pTemp == NULL)	break;
		if (pTemp->next == p) {
			pTemp->next = p->next;
			free(p);
			return true;
		}
		pTemp = pTemp->next;
	}
	return false;
}
//头插
void push_front(struct Node** pHead, int data) {
	if (pHead == NULL)	return;
	Node* p = creatListNode(data);
	/*if (NULL == *pHead) {
		*pHead = p;
		return;
	}*/
	p->next = *pHead;
	*pHead = p;
}

循环单链表

链表最后一个节点的next指针指向链表头结点（无头的）

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

//创建节点的函数
struct Node* creatListNode(int data);


//尾插
void push_back(struct Node** pHead, int data);
//遍历
void travel(struct Node* head);

//头插
void push_front(struct Node** pHead, int data);



void travel(Node* pHead) {
	if (NULL == pHead) {
		return;
	}
	Node* pTemp = pHead;
	bool isStar = true;
	printf("list:");
	while (1) {
		if (pTemp == pHead) {
			if (isStar)	isStar = false;
			else break;
		}
		printf("%d ", pTemp->data);
		pTemp = pTemp->next;
	}
	printf("\n");
}

int main() {

	Node* list = NULL;
	for (int i = 0; i < 10; i++) {
		push_front(&list, i);
		travel(list);
	}


	while (1);
	return 0;
}
//创建节点
Node* creatListNode(int data) {
	Node* pNew = (Node*)malloc(sizeof(Node));
	assert(pNew);
	pNew->data = data;
	pNew->next = NULL;
	return pNew;
}
void push_back(Node** pHead, int data) {
	if (NULL == pHead)	return;
	Node* pNew = creatListNode(data);
	if (NULL == *pHead) {
		*pHead = pNew;
		(*pHead)->next = *pHead;
		return;
	}
	Node* p = *pHead;		//找到最后一个节点
	while (1) {
		if (p->next == *pHead)	break;
		p = p->next;
	}
	p->next = pNew;
	pNew->next = *pHead;
}


void push_front(struct Node** pHead, int data) {
	if (pHead == NULL)	return;
	Node* pNew = creatListNode(data);
	if (*pHead == NULL) {//0-1
		*pHead = pNew;
		(*pHead)->next = *pHead;
		return;
	}
	Node* pTail = *pHead;
	while (1){			//找到最后一个节点
		if (pTail->next == *pHead)	break;
		pTail = pTail->next;
	}
	//新节点成为头结点
	pNew->next = *pHead;
	*pHead = pNew;

	//最后一个节点的next指针指向新的头结点
	pTail->next = *pHead;

}

双链表

  • next指针指向下一个节点
  • pret指针指向前一个节点
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
struct Node{
	int				data;
	struct Node*	pNext;
	struct Node*	pPret;
};

struct List{
	struct Node*	pHead;		//指向链表的头结点
	struct Node*	pTail;		//指向链表的尾结点
};

void init(struct List* l) {
	l->pHead = l->pTail = NULL;
}
struct Node* createListNode(int data);
void travel_back(struct List* list);
void travel_front(struct List* list);
void push_back(struct List* list,int data);
void push_front(struct List* list,int data);
void deleteNodeByPos(struct List* list, int pos);
void deleteNodeByData(struct List* list, int data);

int main() {
	struct List* list;
	init(&list);
	for (int i = 0; i < 10; i++){
		push_back(&list, i);
	}
	travel_back(&list);
	travel_front(&list);
	int n;

	while (1) {
		printf("要删第几个:");
		scanf_s("%d", &n);
		//deleteNodeByPos(&list, n);
		deleteNodeByData(&list, n);
		travel_back(&list);
		travel_front(&list);
	}
	return 0;
}

struct Node* createListNode(int data) {
	struct Node* pNew = malloc(sizeof(struct Node));
	assert(pNew);
	memset(pNew, 0, sizeof(struct Node));
	pNew->data = data;
	return pNew;
}
void travel_back(struct List* list) {
	if (NULL == list)	return;
	printf("travel_back:");
	struct Node* p = list->pHead;
	while (p) {
		printf("%d ", p->data);
		p = p->pNext;
	}
	printf("\n");
}
void travel_front(struct List* list) {
	if (NULL == list)	return;
	printf("travel_front:");
	struct Node* p = list->pTail;
	while (p) {
		printf("%d ", p->data);
		p = p->pPret;
	}
	printf("\n");
}
void push_back(struct List* list,int data) {
	if (NULL == list)	return;
	struct Node* pNew = createListNode(data);
	if (NULL == list->pTail) {
		list->pHead = list->pTail = pNew;
		return;
	}
	list->pTail->pNext = pNew;
	pNew->pPret = list->pTail;
	list->pTail = pNew;
}
void push_front(struct List* list, int data) {
	if (NULL == list)	return;
	struct Node* pNew = createListNode(data);
	if (NULL == list->pHead) {
		list->pHead = list->pTail = pNew;
		return;
	}
	list->pHead->pPret = pNew;
	pNew->pNext = list->pHead;
	list->pHead = pNew;
}
void deleteNodeByPos(struct List* list, int pos) {
	if (NULL == list || pos < 1)	return;
	struct Node* p = list->pHead;		//从前往后
	int len = 0;		//链表长度
	while (p) {
		len++;
		p = p->pNext;
	}
	if (len < pos)	return;
	if (1 == pos) {//改头
		if (len == 1) {
			list->pHead = list->pTail = NULL;
		}
		else  {
			list->pHead = list->pHead->pNext;
			list->pHead->pPret = NULL;
		}
		free(p);
		return;
	}
	if (pos == len) {//改尾
		p = list->pTail;
		list->pTail = list->pTail->pPret;
		list->pTail->pNext = NULL;
		free(p);
		return;
	}
	p = list->pHead;		//重新指向头结点
	//移到要删节点
	for (int i = 1; i < pos; i++){
		p = p->pNext;
	}

	p->pPret->pNext = p->pNext;
	p->pNext->pPret = p->pPret;
	free(p);

}
void deleteNodeByData(struct List* list, int data) {
	if (NULL == list)	return;
	struct Node* p = list->pHead;
	while (1) {
		if (NULL == p)	return;
		if (data == p->data) {
			if (p == list->pHead && p == list->pTail) {
				free(p);
				list->pHead = list->pTail = NULL;
				return;
			}
			if (p == list->pHead) {//删头
				p->pNext->pPret = NULL;
				list->pHead = p->pNext;
				free(p);
				return;//结束
			}
			if (p == list->pTail) {//删尾
				p->pPret->pNext = NULL;
				list->pTail = p->pPret;
				free(p);
				return;
			}

			//删中间
			//pDel的前一个的pNext指针指向pDel的后一个
			p->pPret->pNext = p->pNext;

			//pDel的后一个的pPret指针指向pDel的前一个
			p->pNext->pPret = p->pPret;

			free(p);
			return;
		}
		p = p->pNext;
	}
}

循环双链表

  • 第一个节点的pPret指针指向尾节点
  • 最后一个节点的怕Next指针指向头节点

构成循环

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
struct Node {
	int				data;
	struct Node* pNext;
	struct Node* pPret;
};

struct List {
	struct Node* pHead;		//指向链表的头结点
	struct Node* pTail;		//指向链表的尾结点
};

void init(struct List* l) {
	l->pHead = l->pTail = NULL;
}
struct Node* createListNode(int data);
void travel_back(struct List* list);
void travel_front(struct List* list);
void push_back(struct List* list, int data);
void push_front(struct List* list, int data);
void deleteNodeByPos(struct List* list, int pos);
void deleteNodeByData(struct List* list, int data);

int main() {
	struct List* list;
	init(&list);
	for (int i = 0; i < 10; i++) {
		push_back(&list, i);
	}
	travel_back(&list);
	travel_front(&list);
	int n;

	while (1) {
		printf("要删第几个:");
		scanf_s("%d", &n);
		//deleteNodeByPos(&list, n);
		deleteNodeByData(&list, n);
		travel_back(&list);
		travel_front(&list);
	}
	return 0;
}

struct Node* createListNode(int data) {
	struct Node* pNew = malloc(sizeof(struct Node));
	assert(pNew);
	memset(pNew, 0, sizeof(struct Node));
	pNew->data = data;
	return pNew;
}
void travel_back(struct List* list) {
	if (NULL == list)	return;
	printf("travel_back:");
	struct Node* p = list->pHead;
	bool is = true;
	while (p) {
		if (p == list->pHead) {
			if (is)	is = false;
			else	return;
		}
		printf("%d ", p->data);
		p = p->pNext;
	}
	printf("\n");
}
void travel_front(struct List* list) {
	if (NULL == list)	return;
	printf("travel_front:");
	struct Node* p = list->pTail;
	bool is = true;
	while (p) {
		if (p == list->pTail) {
			if (is)	is=false;
			else	return;
		}
		printf("%d ", p->data);
		p = p->pPret;
	}
	printf("\n");
}
void push_back(struct List* list, int data) {
	if (NULL == list)	return;
	struct Node* pNew = createListNode(data);
	if (list->pHead == list->pTail) {
		list->pHead = list->pTail = pNew;
		return;
	}
	list->pTail->pNext = pNew;
	pNew->pPret = list->pTail;
	list->pTail = pNew;
	list->pTail->pNext = list->pHead;
}
void push_front(struct List* list, int data) {
	if (NULL == list)	return;
	struct Node* pNew = createListNode(data);
	if (list->pTail == list->pHead) {
		list->pHead = list->pTail = pNew;
		return;
	}
	list->pHead->pPret = pNew;
	pNew->pNext = list->pHead;
	list->pHead = pNew;
	list->pHead->pPret = list->pTail;
}

较简单，不多写

复杂数据类型

只需要在赋值的时候改变就行

  • 可以直接memcpy内存拷贝
  • 分别赋值

数据是不影响结构的

链表概述：结构、类型及基本操作
11-04
链表之所以被广泛使用，是因为它们在某些方面比数组等其他数据结构具有优势。 链表的主要类型包括单向链表、双向链表和循环链表。在单向链表中，每个节点只有一个指针，指向下一个节点，形成单向链接；双向链表的每...
单链表与双链表：结构、操作与应用的比较
11-25
单链表和双链表各有优势和局限，了解它们之间的区别，并能够根据实际应用选择合适的链表类型，对于提高编程效率和程序性能都至关重要。无论是在学习数据结构的基础知识，还是在实际软件开发中，对这两种链表的深入...
深入解析链表：结构、实现与应用全指南
2403_87794049的博客
04-12 949
/ 单链表结点int data;// 数据域，存储具体数据// 指针域，指向下一个结点（NULL表示链尾）// 双向链表结点（增加前驱指针）int data;// 指向前驱结点// 指向后继结点链表的本质是通过指针实现动态逻辑结构，其设计体现了计算机科学中 “间接层” 的智慧 —— 用额外的指针域换取操作的灵活性。指针操作的精准控制：理解指针传递、解引用的底层机制边界条件的全面处理：空链表、头结点、尾结点的特殊情况数学建模能力：如环形链表的快慢指针证明、时间复杂度分析。
Python数据结构之链表：操作与实现
weixin_35755562的博客
05-20 986
链表由一系列节点组成，每个节点包含数据部分和指向下一个节点的引用。它是一种动态数据结构，可以在运行时进行内存分配和回收，使其在处理未知数量的数据时显得非常灵活。环形链表是一种特殊的链表，其尾节点的next指针指向头节点，形成一个环。这种结构使得链表没有明确的开始和结束，适合于需要循环遍历的场景，如约瑟夫环问题或实现循环队列。
数据结构之链表的实现
qq_28576837的博客
08-10 1115
链表分为单链表、双链表、循环链表先看最简单的单链表。
数据结构之链表简介：原理、实现与应用
m0_70066267的博客
02-26 931
链表是一种非常灵活且高效的数据结构，适用于多种编程场景。通过本文的介绍，读者应该对链表的基本概念、实现方式和应用场景有了深入的理解。链表的动态性、高效的插入和删除操作，使其在许多实际应用中都表现出色。希望本文能为你在技术论坛上分享和讨论链表提供一些有价值的参考。
【java-数据结构篇】揭秘 Java LinkedList：链表数据结构的 Java 实现原理与核心概念
2301_80350265学无止尽5的博客
11-30 8176
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引⽤将节点连接起来了，因此在在任意位置插⼊或者删除元素时，不需要搬移元素，效率⽐较⾼。链表是一种通过指针将数据节点连接起来的数据结构，链表是⼀种物理存储结构上⾮连续存储结构，数据元素的逻辑顺序是通过链表中的引⽤链接次序实现的。但是如果要在指定节点之前插入新节点，需要先遍历链表找到该节点的前驱节点，这会比较复杂，尤其是在没有额外的头节点辅助的情况下。的底层是一个双向链表，由节点（Node）组成。
高级链表操作：结构设计与算法优化
yll7702的博客
07-08 898
本文深入探讨了高级链表操作的技术要点与实践方法。首先分析了链表在现代计算系统中的核心价值，特别是动态数据管理和高并发场景的应用优势。随后详细解析了单链表的优化策略，包括内存对齐、哨兵节点设计和快慢指针技巧，以及双向链表和循环链表的特殊应用场景。文章还介绍了工程实践中的模块化设计、泛型支持方案，并剖析了典型算法题目和性能优化手段。最后通过Linux内核等实际案例，展示了链表在系统编程中的关键作用。全文为开发者提供了从基础到高阶的链表技术全景视角。
数据结构与算法：链表的C/C++实现
2401_86771711的博客
08-17 2646
数据结构是计算机科学中的一个核心概念，它定义了数据的组织、管理和存储方式，以便可以高效地访问和修改数据。链表是一种基础的数据结构，它由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。链表可以是单向的，也可以是双向的，甚至可以是循环的。
c语言数据结构——链表的实现及其基本操作
希望自己从编程小白变成大佬
04-06 4692
顺序表的问题及思考中间/头部的插入删除，时间复杂度为O(N)增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。思考：如何解决以上问题呢？下面我们给出了链表的结构，让我们来看看吧。
【数据结构】链表：插入、删除
Swillow_的博客
07-01 3622
我是通过b站的教程(如下图)学习的，这里记录下学习笔记。数据结构简单导言(为什么会出现数据结构？在日常生活中，为了组织不同类型的数据，我们需要不同类型的结构，帮助我们更高效更方便的找到想要的数据。
深入理解C语言链表：数据结构的基石
nplplus的博客
03-07 1308
在C语言中，借助结构体（struct）c// 定义链表节点结构int data;// 数据域，这里存储整数// 指针域，指向下一个节点在这个定义中，struct Node 代表链表节点的类型。data 成员用于存放具体的数据（这里设定为 int 类型）；next 是一个指针，指向 struct Node 类型的对象，即下一个链表节点，如此构建起链表的链式结构。
计算机科学：C++中链表数据结构详解及其基本操作实现
11-02
此外还详尽解析了用C++语言分别针对单链表、双链表、循环链表这三种类型的典型实例化结构进行编码的具体步骤，涵盖了节点创建、多种方式下的节点插入和移除以及列表的完整遍历等多方面的实用操作指南。 适合人群：...
链表数据结构及其基本操作介绍与实现
11-02
内容概要：本文详细介绍了链表作为一种常用数据结构的概念、优势以及不同类型（单链表、双链表、循环链表）的基本操作。每种类型的链表都包括节点定义、插入操作、删除操作和遍历操作的具体实现。具体代码示例采用 ...
python数据结构实现（一）：数组和链表及相关LeetCode题 数组和链表.pdf
04-18
链表的主要优势在于插入和删除操作的效率，因为这些操作只需要改变相邻节点的引用，而不需要像数组那样移动元素。然而，链表不支持随机访问，获取链表中任意位置的元素需要从头节点开始遍历。 在LeetCode等算法题目...
【数据结构】图 ，拓扑排序 未完
最新发布
oDianZi1234567的博客
07-14 310
参考：AB13 【模板】拓扑排序。
数据结构——深度优先搜索与广度优先搜索的实现
2401_88020079的博客
07-09 415
好了，温习过基础深度遍历方法后，我们来介绍广度优先遍历，所谓广度优先遍历就是一层一层的遍历，不再追求走到叶子结点，而是从左到右一步步走完，所以，广度优先遍历多被用于寻找最短路的题目中。好了，介绍完深度优先遍历与广度优先遍历的写法后，我们还有一个拓展知识点——仔细思考一下，如果使用深度优先遍历，如果层数太多我们在写一个搜索时会时常遇到加载慢的问题，而如果我们使用记忆化搜索，随着数据量的增多，不免会积累海量的数据。————————————本栏目旨在交流计算机知识，欢迎交流指正！
终极剖析HashMap：数据结构、哈希冲突与解决方案全解
yiridancan的博客
07-13 612
优秀的工程设计是在数学理论与硬件特性间寻找平衡点。HashMap的成功在于它用分层防御体系将冲突概率降到最低，用尾插法+红黑树解决了链地址法的固有缺陷，最终成就了Java集合框架中最璀璨的明珠。
Redis底层数据结构
qinwenjng120的博客
07-11 1106
通过添加的这些参数，可以更方便解析字符串。例如，如果用数组方式保存字符串，那么读取完整字符串就只能遍历数组里的各个字节数据，时间复杂度O(N)。但是SDS中预先记录了len后，就可以直接读取一定长度的字节，时间复杂度O(1)，效率更高。另外，C语言中通常用字节数组保存字符串，那么还需要定义一个特殊的结束符\0表示这一个字符串结束。但是在Redis中，如果value中就包含\0这样的字符串，就会产生歧义。根据不同的键值，选择不同的编码方式（不同的底层数据结构）， int | embstr | raw。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值