深入手撕链表

最新推荐文章于 2024-09-17 14:30:13 发布
最新推荐文章于 2024-09-17 14:30:13 发布
阅读量960 收藏 15
点赞数 12
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72224727/article/details/141791853
版权

链表

分类
链表
单链表
双向链表
种类
循环与非循环
带头与不带头
STL
list

概念

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
在这里插入图片描述
单向与双向
在这里插入图片描述
带头与不带头
在这里插入图片描述
循环与不循环
在这里插入图片描述

单链表

增

尾插

带头

void SLPushBack(SLNode* head, SLNDataType x) {

	SLNode* newnode = CreateNode(x);

	SLNode* tail = head;
	while (tail->next != NULL) {
		tail = tail->next;
	}
	tail->next = newnode;
	
}

不带头

void SLPushBack(SLNode** head, SLNDataType x) {

	assert(head);//头节点的地址不可能为空

	SLNode* newnode = CreateNode(x);

	if (*head == NULL) {//没有节点
		*head = newnode;
	}
	else {
		//找尾
		SLNode* tail = *head;
		while (tail->next != NULL) {
			tail = tail->next;
		}
		tail->next = newnode;
	}

}

头插

带头

void SLPushPront(SLNode* head, SLNDataType x) {

	SLNode* newnode = CreateNode(x);

	newnode->next = head->next;
	head->next = newnode;
}

不带头

void SLPushPront(SLNode** head, SLNDataType x) {
	
	assert(head);

	SLNode* newnode = CreateNode(x);

	newnode->next = *head;
	*head = newnode;
}

插入

带头

void SLInsert(SLNode* head, SLNode* pos, SLNDataType x) {

	assert(head);
	assert(pos);

	SLNode* prev = head;
	while (prev->next != pos) {
		prev = prev->next;
	}

	SLNode* newnode = CreateNode(x);
	newnode->next = pos;
	prev->next = newnode;
}

不带头

void SLInsert(SLNode** head, SLNode* pos, SLNDataType x) {

	assert(head);
	assert(pos);
	assert(*head);

	if (*head == pos) {
		//头插
		SLPushPront(head, x);
	}else{
		SListNode* prev = *head;
		while (prev->next != pos) {
			prev = prev->next;
		}

		SListNode* newnode = CreateNode(x);
		newnode->next =pos;
		prev->next = newnode;
	}

}

删

尾删

带头

void SLPopBack(SLNode* head) {

	assert(head);
	assert(head->next);

	SLNode* prev = head;
	while (prev->next->next != NULL) {
		prev = prev->next;
	}

	free(prev->next);
	prev->next = NULL;
}

不带头

void SLPopBack(SLNode** head) {

	assert(head);
	assert(*head);

	if ((*head)->next == NULL) {
		free(*head);
		*head = NULL;
	}
	else {
		SLNode* prev = *head;
		while (prev->next->next != NULL) {
			prev = prev->next;
		}
		free(prev->next);
		prev->next = NULL;
	}
}

头删

带头

void SLPopFront(SLNode* head) {

	assert(head);
	assert(head->next);

	SLNode* tmp = head->next;
	head->next = head->next->next;

	free(tmp);
}

不带头

void SLPopFront(SLNode** head) {

	assert(head);
	assert(*head);

	SLNode* tmp = *head;
	*head = (*head)->next;

	free(tmp);
}

删除

带头

void SLErase(SLNode* head, SLNode* pos) {

	assert(head);
	assert(head->next);
	assert(pos);

	SLNode* prev = head;
	while (prev->next != pos) {
		prev = prev->next;
	}

	prev->next = pos->next;

	free(pos);
	pos = NULL;
}

不带头

void SLErase(SLNode** head, SLNode* pos) {

	assert(head);
	assert(pos);

	if (*head == pos) {
		SLPopFront(head);
	}
	else {
		SLNode* prev = *head;
		while (prev->next != pos) {
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

查

带头

SLNode* SLFind(SLNode* head, SLNDataType x) {

	SLNode* cur = head->next;
	while (cur) {
		if (cur->val == x) {
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

不带头

SLNode* CreateNode(SLNDataType x) {

	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL) {
		perror("malloc fail");
		exit(-1);
	}

	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

完整实现

带头

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

typedef int SLNDataType;

typedef struct SListNode {
	SLNDataType val;
	struct SListNode* next;
}SLNode;

void SLPrint(SLNode* head);

void SLPushBack(SLNode* head, SLNDataType x);
void SLPushPront(SLNode* head, SLNDataType x);

SLNode* SLFind(SLNode* head, SLNDataType x);

void SLInsert(SLNode* head, SLNode* pos, SLNDataType x);

void SLPopBack(SLNode* head);
void SLPopFront(SLNode* head);
void SLErase(SLNode* head, SLNode* pos);

void SLDestroy(SLNode* head);

#include"SList.h"

void SLPrint(SLNode* head) {
	while (head) {
		printf("%d -> ", head->val);
		head = head->next;
	}
	printf("NULL\n");
}

SLNode* CreateNode(SLNDataType x) {

	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL) {
		perror("malloc fail");
		exit(-1);
	}

	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

void SLPushBack(SLNode* head, SLNDataType x) {

	SLNode* newnode = CreateNode(x);

	SLNode* tail = head;
	while (tail->next != NULL) {
		tail = tail->next;
	}
	tail->next = newnode;
	
}

void SLPushPront(SLNode* head, SLNDataType x) {

	SLNode* newnode = CreateNode(x);

	newnode->next = head->next;
	head->next = newnode;
}

SLNode* SLFind(SLNode* head, SLNDataType x) {

	SLNode* cur = head->next;
	while (cur) {
		if (cur->val == x) {
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

void SLInsert(SLNode* head, SLNode* pos, SLNDataType x) {

	assert(head);
	assert(pos);

	SLNode* prev = head;
	while (prev->next != pos) {
		prev = prev->next;
	}

	SLNode* newnode = CreateNode(x);
	newnode->next = pos;
	prev->next = newnode;
}

void SLPopBack(SLNode* head) {

	assert(head);
	assert(head->next);

	SLNode* prev = head;
	while (prev->next->next != NULL) {
		prev = prev->next;
	}

	free(prev->next);
	prev->next = NULL;
}

void SLPopFront(SLNode* head) {

	assert(head);
	assert(head->next);

	SLNode* tmp = head->next;
	head->next = head->next->next;

	free(tmp);
	tmp = NULL;
}

void SLErase(SLNode* head, SLNode* pos) {

	assert(head);
	assert(head->next);
	assert(pos);

	SLNode* prev = head;
	while (prev->next != pos) {
		prev = prev->next;
	}

	prev->next = pos->next;

	free(pos);
	pos = NULL;
}

void SLDestroy(SLNode* head) {
	
	assert(head);

	SLNode* cur = head->next;
	while(cur){
		SLNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}

	head->next = NULL;
}

#include"SList.h"

void test1() {
	SListNode* plist = (SListNode*)malloc(sizeof(SListNode));
	plist->val = 0;
	plist->next = NULL;

	SLPushBack(plist, 1);
	SLPushBack(plist, 3);
	SLPushBack(plist, 1);
	SLPushBack(plist, 4);

	SLPrint(plist -> next);

	SLPushPront(plist, 0);
	SLPushPront(plist, 2);
	SLPushPront(plist, 5);

	SLPrint(plist->next);
}

void test2() {
	SListNode* plist = (SListNode*)malloc(sizeof(SListNode));
	plist->val = 0;
	plist->next = NULL;

	SLPushBack(plist, 1);
	SLPushBack(plist, 3);
	SLPushBack(plist, 1);
	SLPushBack(plist, 4);

	SLPrint(plist->next);

	SLPushPront(plist, 0);
	SLPushPront(plist, 2);
	SLPushPront(plist, 5);

	SLPrint(plist->next);

	SLInsert(plist, SLFind(plist->next, 5), 520);

	SLPrint(plist->next);
}

void test3() {
	SListNode* plist = (SListNode*)malloc(sizeof(SListNode));
	plist->val = 0;
	plist->next = NULL;

	SLPushBack(plist, 1);

	SLPopBack(plist);

	SLPrint(plist->next);
}

void test4() {
	SListNode* plist = (SListNode*)malloc(sizeof(SListNode));
	plist->val = 0;
	plist->next = NULL;

	SLPushBack(plist, 1);
	SLPushBack(plist, 3);
	SLPushBack(plist, 1);
	SLPushBack(plist, 4);

	SLPrint(plist->next);

	SLPushPront(plist, 0);
	SLPushPront(plist, 2);
	SLPushPront(plist, 5);

	SLPrint(plist->next);

	SLPopFront(plist);
	SLPopFront(plist);
	SLPopFront(plist);

	SLPrint(plist->next);
}

void test5() {
	SListNode* plist = (SListNode*)malloc(sizeof(SListNode));
	plist->val = 0;
	plist->next = NULL;

	SLPushBack(plist, 1);
	SLPushBack(plist, 3);
	SLPushBack(plist, 1);
	SLPushBack(plist, 4);

	SLPrint(plist->next);

	SLPushPront(plist, 0);
	SLPushPront(plist, 2);
	SLPushPront(plist, 5);

	SLPrint(plist->next);

	SLErase(plist, SLFind(plist, 0));

	SLPrint(plist->next);
}


int main() {
	
	test5();

	return 0;
}

不带头

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

typedef int SLNDataType;

typedef struct SListNode {
	SLNDataType val;
	struct SListNode* next;
}SLNode;

void SLPrint(SLNode* head);

void SLPushBack(SLNode** head, SLNDataType x);//尾插
void SLPushPront(SLNode** head, SLNDataType x);//头插
void SLInsert(SLNode** head, SLNode* pos, SLNDataType x); //插入

SLNode* SLFind(SLNode* head,SLNDataType x);//查找

void SLPopBack(SLNode** head);//尾删
void SLPopFront(SLNode** head);//头删
void SLErase(SLNode** head, SLNode* pos);//删除

void SLInsertAfter(SLNode* pos, SLNDataType x);//往后插
void SLEraseAfter(SLNode* pos);//往后删

void SLDestroy(SLNode** head);//清除

#include"SList.h"

void SLPrint(SLNode* head) {
	while (head) {
		printf("%d -> ", head->val);
		head = head->next;
	}
	printf("NULL\n");
}

SLNode* CreateNode(SLNDataType x) {

	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL) {
		perror("malloc fail");
		exit(-1);
	}

	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

void SLPushBack(SLNode** head, SLNDataType x) {

	assert(head);//头节点的地址不可能为空

	SLNode* newnode = CreateNode(x);

	if (*head == NULL) {//没有节点
		*head = newnode;
	}
	else {
		//找尾
		SLNode* tail = *head;
		while (tail->next != NULL) {
			tail = tail->next;
		}
		tail->next = newnode;
	}

}

void SLPushPront(SLNode** head, SLNDataType x) {
	
	assert(head);

	SLNode* newnode = CreateNode(x);

	newnode->next = *head;
	*head = newnode;
}

SLNode* SLFind(SLNode* head, SLNDataType x) {

	while (head) {
		if (head->val == x) {
			return head;
		}
		head = head->next;
	}

	return NULL;
}

void SLInsert(SLNode** head, SLNode* pos, SLNDataType x) {

	assert(head);
	assert(pos);
	assert(*head);

	if (*head == pos) {
		//头插
		SLPushPront(head, x);
	}else{
		SListNode* prev = *head;
		while (prev->next != pos) {
			prev = prev->next;
		}

		SListNode* newnode = CreateNode(x);
		newnode->next =pos;
		prev->next = newnode;
	}

}

void SLPopBack(SLNode** head) {

	assert(head);
	assert(*head);

	if ((*head)->next == NULL) {
		free(*head);
		*head = NULL;
	}
	else {
		SLNode* prev = *head;
		while (prev->next->next != NULL) {
			prev = prev->next;
		}
		free(prev->next);
		prev->next = NULL;
	}
}

void SLPopFront(SLNode** head) {

	assert(head);
	assert(*head);

	SLNode* tmp = *head;
	*head = (*head)->next;

	free(tmp);
}

void SLErase(SLNode** head, SLNode* pos) {

	assert(head);
	assert(pos);

	if (*head == pos) {
		SLPopFront(head);
	}
	else {
		SLNode* prev = *head;
		while (prev->next != pos) {
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

void SLInsertAfter(SLNode* pos, SLNDataType x) {

	assert(pos);

	SLNode* newnode = CreateNode(x);
	
	newnode->next = pos->next;
	pos->next = newnode;
}

void SLEraseAfter(SLNode* pos) {

	assert(pos);
	assert(pos->next);

	SLNode* cur = pos->next;
	pos->next = cur->next;

	free(cur);
	cur = NULL;
}

void SLDestroy(SLNode** head) {
	
	assert(head);

	SLNode* cur = *head;
	while (cur) {
		SLNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*head = NULL;
}

#include"SList.h"

void test1() {
	SListNode* plist = NULL;

	SLPushBack(&plist, 1);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 4);

	SLPrint(plist);

	SLPushPront(&plist, 0);
	SLPushPront(&plist, 2);
	SLPushPront(&plist, 5);

	SLPrint(plist);
}

void test2() {
	SListNode* plist = NULL;

	SLPushBack(&plist, 1);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 4);

	SLPrint(plist);

	SLPushPront(&plist, 0);
	SLPushPront(&plist, 2);
	SLPushPront(&plist, 5);

	SLPrint(plist);

	SLInsert(&plist, SLFind(plist, 2), 10);

	SLPrint(plist);
}

void test3() {
	SListNode* plist = NULL;

	SLPushBack(&plist, 1);
	
	SLPopBack(&plist);

	SLPrint(plist);
}

void test4() {
	SListNode* plist = NULL;

	SLPushBack(&plist, 1);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 4);

	SLPrint(plist);

	SLPushPront(&plist, 0);
	SLPushPront(&plist, 2);
	SLPushPront(&plist, 5);

	SLPrint(plist);

	SLErase(&plist, SLFind(plist, 0));

	SLPrint(plist);
}

int main() {

	test4();

	return 0;
}

双向链表

在这里插入图片描述

初始化

DLNode* DLInit() {

	DLNode* head = CreatDLNode(-1);
	head->next = head;
	head->prev = head;

	return head;
}

增

尾插

void DLPushBack(DLNode* head, DLTDataType x) {
	
	assert(head);

	DLNode* tail = head->prev;
	DLNode* newnode = CreatDLNode(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = head;
	head->prev = newnode;
}

头插

void DLPushPront(DLNode* head, DLTDataType x) {

	assert(head);

	DLNode* tail = head->next;
	DLNode* newnode = CreatDLNode(x);

	head->next = newnode;
	newnode->prev = head;
	newnode->next = tail;
	tail->prev = newnode;
}

插入

void DLInsert(DLNode* pos, DLTDataType x) {

	assert(pos);

	DLNode* tail = pos->prev;
	DLNode* newnode = CreatDLNode(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = pos;
	pos->prev = newnode;
}

删

void DLErase(DLNode* pos) {

	assert(pos);
	assert(pos != head);

	DLNode* tail = pos->prev;
	
	tail->next = pos->next;
	pos->next->prev = tail;

	free(pos);
}

查

DLNode* DLFind(DLNode* head, DLTDataType x) {

	assert(head);

	DLNode* cur = head->next;
	while (cur != head) {
		if (cur->val == x) {
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

完整代码

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

typedef int DLTDataType;

typedef struct DList{
	struct DList* next;
	struct DList* prev;
	DLTDataType val;
}DLNode;

DLNode* DLInit();

void DLPrint(DLNode* head);

void DLPushBack(DLNode* head, DLTDataType x);
void DLPushPront(DLNode* head, DLTDataType x);
void DLInsert(DLNode* pos, DLTDataType x);

DLNode* DLFind(DLNode* head, DLTDataType x);

void DLPopBack(DLNode* head);
void DLPopFront(DLNode* head);
void DLErase(DLNode* pos);

void DLDestroy(DLNode* head);

#include"DList.h"

DLNode* CreatDLNode(DLTDataType x) {

	DLNode* newnode = (DLNode*)malloc(sizeof(DLNode));
	if (newnode == NULL) {
		perror("malloc fail");
		exit(-1);
	}

	newnode->val = x;
	newnode->next = NULL;
	newnode->prev = NULL;

	return newnode;
}

DLNode* DLInit() {

	DLNode* head = CreatDLNode(-1);
	head->next = head;
	head->prev = head;

	return head;
}

void DLPrint(DLNode* head) {

	assert(head);
	printf("head <=> ");

	DLNode* cur = head->next;
	while (cur != head) {
		printf("%d <=> ", cur->val);
		cur = cur->next;
	}
	printf("\n");
}

void DLPushBack(DLNode* head, DLTDataType x) {
	
	assert(head);

	DLNode* tail = head->prev;
	DLNode* newnode = CreatDLNode(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = head;
	head->prev = newnode;
}

void DLPushPront(DLNode* head, DLTDataType x) {

	assert(head);

	DLNode* tail = head->next;
	DLNode* newnode = CreatDLNode(x);

	head->next = newnode;
	newnode->prev = head;
	newnode->next = tail;
	tail->prev = newnode;
}

DLNode* DLFind(DLNode* head, DLTDataType x) {

	assert(head);

	DLNode* cur = head->next;
	while (cur != head) {
		if (cur->val == x) {
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

void DLInsert(DLNode* pos, DLTDataType x) {

	assert(pos);

	DLNode* tail = pos->prev;
	DLNode* newnode = CreatDLNode(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = pos;
	pos->prev = newnode;
}

void DLPopBack(DLNode* head) {
	
	assert(head);

	assert(head->next != head);

	DLErase(head->prev);
}

void DLPopFront(DLNode* head) {

	assert(head);

	assert(head->next != head);

	DLErase(head->next);
}

void DLErase(DLNode* pos) {

	assert(pos);

	DLNode* tail = pos->prev;
	
	tail->next = pos->next;
	pos->next->prev = tail;

	free(pos);
}

void DLDestroy(DLNode* head) {

	assert(head);

	DLNode* cur = head->next;
	while (cur != head) {
		DLNode* tail = cur->next;
		free(cur);
		cur = tail;
	}

	free(head);
}

#include"DList.h"

void test1() {
	DLNode* head = DLInit();

	DLPushBack(head, 1);
	DLPushBack(head, 3);
	DLPushBack(head, 1);
	DLPushBack(head, 4);

	DLPushPront(head, 0);
	DLPushPront(head, 2);
	DLPushPront(head, 5);

	DLPrint(head);
}

void test2() {
	DLNode* head = DLInit();

	DLPushBack(head, 1);
	DLPushBack(head, 3);
	DLPushBack(head, 1);
	DLPushBack(head, 4);

	DLPushPront(head, 0);
	DLPushPront(head, 2);
	DLPushPront(head, 5);

	DLPrint(head);
    
	DLInsert(DLFind(head, 2), 3);

	DLPrint(head);
}

void test3() {
	DLNode* head = DLInit();

	DLPushBack(head, 1);
	DLPushBack(head, 3);
	DLPushBack(head, 1);
	DLPushBack(head, 4);

	DLPushPront(head, 0);
	DLPushPront(head, 2);
	DLPushPront(head, 5);

	DLPrint(head);

	DLInsert(DLFind(head, 2), 3);

	DLPrint(head);

	DLErase(DLFind(head, 3));

	DLPopBack(head);
	DLPopFront(head);

	DLPrint(head);
}

int main() {

	test3();

	return 0;
}

数组

接下来我们用数组简单实现一下链表，可以用于一些oj题。
Ldawn_AI
关注
专栏目录
手撕算法官方PDF正版。
10-27
《手撕算法》是一本备受推崇的算法学习资料，它以独特的方式深入浅出地讲解了计算机科学中的算法思想和技巧。这本书的核心目标是帮助读者理解算法的本质，提高解决实际问题的能力，尤其对于准备面试或者想要提升编程...
leetcode:手撕leetcode
03-18
在本指南中，我们将聚焦于使用C++语言解决LeetCode上的问题，通过实践来深入理解和掌握C++在算法实现中的应用。 C++是一种强大的、通用的编程语言，以其高效的性能、丰富的库支持以及面向对象的特性而备受赞誉。在...
顺序表和链表 手撕链表深入解析链表实现
一名在校大三学习JAVA
04-17 781
线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构 常见的线性表 顺序表，链表，栈，队列，字符串（因为本质还是字符数组）......... 线性表就是让多个相同数据类型元素逻辑上呈直线排列，逻辑上连续（逻辑连续就是想象它是连续的，但现实中不一定是要由连续的内存实现），但是物理上不一定连续，这种数据结构就叫做线性表 线性表的存储在物理上通常用数组或者链式结构实现 数组结构这种存储方式，在物理上是一个挨着一个，中间没有空隙，在.
【手撕数据结构】链表面试题进阶
apple_61439616的博客
07-31 682
新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。2.设置random指针，这就体现了我们为什么把新链表的节点尾插到旧链表中相对应的节点的好处，我们可以直接通过变量旧链表->random->next指针找到新链表中的random指针的位置。如果其中一个链表比另一个链表长就始终会比短的链表少走一步，这里我们不妨算出两个链表的长度，求他们的差值，让长的链表先走差值步，再长链表和短链表一起走就行了。如果链表无环，则返回 null。
26_1集合实现类研究底层（部分）：手撕ArrayList底层源码、手撕LinkedList底层源码、手写单向链表和双向链表
gangain的博客
03-09 780
手撕实现类1.手撕ArrayList底层源码2.手撕LinkedList底层源码ArrayList 和 LinkedList的效率区别手写单向链表手写双向链表。
算法学习之链表篇
continue_gdufe的博客
09-09 447
算法学习之链表篇前言一、链表设计大师二、小试牛刀1.反转链表2.总结 前言 这是算法学习链表篇的第二篇Blog，由于个人的懒癌+开学琐事，所以拖延了超级久才发布第二篇学习博客，学习是一个持续、长久的过程，希望以后自己能战胜拖延hhh，话不多说，我们继续深究链表，深入学习叭~ 本博客参考了代码随想录，特此声明 一、链表设计大师 我们在链表操作时往往会使用他人写好的函数，我们直接调用即可，这样操作固然方便，但是这不利于我们理解、学习链表，所以，我们不妨来写5个常见的链表操作，你准备成为大师了么？ Le
手撕list链表底层
11-16
2. 手撕链表：手撕链表是指通过手动操作链表底层来实现一些功能，例如插入、删除、查找等操作。通过了解链表的底层结构，可以更好地理解链表的工作原理，并能够编写更高效、更灵活的代码。 3. 内存管理：在处理链表...
手撕代码_C语言手撕_C++_手撕代码c++_
10-01
首先，让我们深入理解堆栈和队列的基本概念。堆栈是一种后进先出（LIFO）的数据结构，它的操作主要有压栈（push）和弹栈（pop）。队列则是一种先进先出（FIFO）的数据结构，支持入队（enqueue）和出队（dequeue）...
H5游戏源码 手撕鬼子.zip
10-15
通过研究这份《H5游戏源码：手撕鬼子》，开发者可以了解到如何利用HTML5相关技术进行游戏开发，同时也能深入理解游戏背后的逻辑设计和实现细节。对于初学者来说，这是一个很好的实践项目，可以提高编程技能；对于有...
从头开始嵌入式第三十八天（数据结构 双向链表）
qq_64792908的博客
09-11 670
2. 相比单向链表，双向链表在某些操作上更加灵活，比如在删除节点时，可以快速找到前驱节点进行调整，而单向链表需要从头开始遍历才能找到前驱节点。1. 每个节点包含两个指针，分别指向直接前驱节点和直接后继节点。这使得在双向链表中可以双向遍历，既可以向前也可以向后查找节点。1. 插入操作：可以快速确定插入位置的前后节点，进行指针调整，实现高效的插入操作。1. 需要频繁进行前后遍历的场景，如文本编辑器中对字符的双向移动和操作。2. 删除操作：由于能够直接访问前驱节点，删除操作也更加方便快捷。
【华为OD】2024D卷——生成哈夫曼树
weixin_45653183的博客
09-12 1377
这是通过构建一种特殊的二叉树来实现的，其中每个字符都位于树的一个叶节点上，且该叶节点到根节点的路径上的边所代表的字符（在哈夫曼编码中通常使用0和1表示）共同构成了该字符的编码。·新节点作为这两个子节点的父节点，而原来的两个节点则成为新节点的左右子节点（通常约定左子节点频率小于等于右子节点）。2、不断从堆中取出两个最小的节点作为左右子树，构造一个新的父节点，其权值为两个节点权值之和，并将新节点插入堆中。·然后，算法反复地选择两个频率最小的节点，将它们合并为一个新的节点，新节点的频率是两个子节点频率之和。
【JavaScript】数据结构之字典 & 哈希表
票票的博客
09-14 576
数据结构之字典和哈希表
数据结构—队列
最新发布
2301_80151359的博客
09-17 300
QueueNode;int size;//保存队列有效数据个数}Queue;初始化队列。
【高阶数据结构】并查集
qq_67582098的博客
09-14 770
【高阶数据结构】并查集
二叉树（上）
xiaochuan_bsj的博客
09-11 1220
主要介绍了树和二叉树的概念方面的大致内容，以及实现二叉树的创建和三种遍历方式。
代码随想录 | Day20 | 二叉树：二叉树所有路径&&左叶子之和
m0_74795952的博客
09-11 564
主要学习内容：1.利用二叉树的谦虚遍历进行题目解答2.to_string函数的使用。
数据结构————栈的讲解(超详细！！！)
braveact的博客
09-11 981
栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出（先进后出）原则。特性与栈的结构有关。
树和二叉树基本术语、性质
snowy_and_sunny的博客
09-14 574
总结二叉树的度、树高、结点数等属性之间的关系（通过王道书 5.2.3 课后小题来复习“二叉 树的性质”）叶子结点的度=0层次默认从1开始 有些题目从0 开始也不要奇怪 满二叉树特点：1.只有最后一层有叶子结点 2.不存在度为1的结点 3.按层序从1开始编号，结点1的左孩子为2i，右孩子为2i+1完全二叉树的特点：1.只有最后两层可能有叶子结点 2.最多只有一个度为1的结点 3.同上3只有一个叶子结点只能是左孩子。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值