【ONE·Data || 带头双向循环链表简单实现】

已于 2022-07-20 22:11:15 修改
阅读量158 收藏
点赞数
分类专栏： # 【ONE·废稿】 文章标签： 数据结构
于 2022-06-05 09:58:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EPIPHANYECHO/article/details/125115840
版权

零、总言

  C语言简单实现带头双向循环链表的各个流程，代码解释在注释中。

文章目录


  
  

一、整体模式：

List.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>//布尔


//双向、带头、循环链表：
typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;

struct List
{
	LTNode* phead;
	int size;
};


//链表初始化
void ListInitform(LTNode** pphead);
//链表初始化改进版
LTNode* ListInit(void);

//链表打印
void ListPrint(LTNode* plist);

//链表尾插
void ListPushBack(LTNode* phead, LTDataType x);
//链表头插
void ListPushFront(LTNode* phead, LTDataType x);
//链表头删
void ListPopBack(LTNode* phead);
//链表尾删
void ListPopFront(LTNode* phead);
//在pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x);
//删除pos位置处的结点
void ListErase(LTNode* pos);

//计算链表长度
int ListSize(LTNode* phead);

//链表销毁
void ListDestory(LTNode* phead);

  
  

Text.c

#include"List.h"

void TestList1()
{
	//测试链表初始化
	//LTNode* plist = NULL;
	//ListInit(&plist);//注意实参传递

	//测试链表初始化改进版
	LTNode* plist = ListInit();
	//测试尾插
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);

	//测试头删
	ListPopFront(plist);
	ListPrint(plist);//1
	ListPopFront(plist);
	ListPrint(plist);//2
	ListPopFront(plist);
	ListPrint(plist);//3
	ListPopFront(plist);
	ListPrint(plist);//4
	ListPopFront(plist);
	ListPrint(plist);//5
	ListPopFront(plist);
	ListPrint(plist);//哨兵位

}

void TestList2()
{
	LTNode* plist = ListInit();
	//从链表为空(只有哨兵位)开始测试头插
	ListPushFront(plist, 1);
	ListPushFront(plist, 2);
	ListPushFront(plist, 3);
	ListPushFront(plist, 4);
	ListPushFront(plist, 5);
	ListPrint(plist);

	//测试尾删
	ListPopBack(plist);
	ListPrint(plist);//1
	ListPopBack(plist);
	ListPrint(plist);//2
	ListPopBack(plist);
	ListPrint(plist);//3
	ListPopBack(plist);
	ListPrint(plist);//4
	ListPopBack(plist);
	ListPrint(plist);//5
	ListPopBack(plist);
	ListPrint(plist);//测试哨兵位


}

void TestList3()
{
	LTNode* plist = ListInit();
	//测试pos作用于头插、尾插
	ListPushFront(plist, 1);
	ListPrint(plist);//1
	ListPushFront(plist, 2);
	ListPrint(plist);//2 1
	ListPushFront(plist, 3);
	ListPrint(plist);//3 2 1

	ListPushBack(plist, 1);
	ListPrint(plist);//3 2 1 1
	ListPushBack(plist, 2);
	ListPrint(plist);//3 2 1 1 2
	ListPushBack(plist, 3);
	ListPrint(plist);//3 2 1 1 2 3

	//测试pos作用于头删、尾删
	ListPopFront(plist);
	ListPrint(plist);//2 1 1 2 3
	ListPopFront(plist);
	ListPrint(plist);//1 1 2 3

	ListPopBack(plist);
	ListPrint(plist);//1 1 2
	ListPopBack(plist);
	ListPrint(plist);//1 1
}

int main(void)
{
	//TestList1();
	//TestList2();
	TestList3();
	return 0;
}

  
  

List.c

#include"List.h"


//辅助函数：动态开辟一个内存空间，新结点，可用于创建哨兵为的头、尾插、头插。
LTNode* BuyListNode(LTDataType x)
{
	//动态开辟:注意malloc的使用细节
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)//开辟失败
	{
		perror("malloc:fail");
		exit(-1);
	}
	//开辟成功时：
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}



//链表初始化：双向链表、带头且循环
//参照之前的单链表，其若不带头也不循环，初始时链表为空，则指向NULL即可，
//但对于此双向链表，其带头、循环，因此但链表中无数据时，初始时要有一个哨兵位的头，且其前驱指针和后续指针都指向自己本身。
//细节：根据TestList1知，要改变实参本身（即链表指针），则此处链表初始函数化中，形参需要使用对应类型的二级指针。
void ListInitform(LTNode** pphead)
{
	*pphead = BuyListNode(-1);//初始时，链表中只有哨兵位的头结点
	(*pphead)->next = *pphead;//处理后续指针指向，使其指向自己
	(*pphead)->prev = *pphead;//处理前驱指针指向，使其指向自己
}

//链表初始化改进版
//由于上述链表初始化需要使用到二级指针，此处改进版是在只使用一级指针的情况下：相应的TestList中接收方法需要变动
LTNode* ListInit(void)
{
	LTNode *phead = BuyListNode(-1);//在初始化函数中创建一个新指针，表示哨兵位的头结点(命名变量的含义在此体现)
	phead->next = phead;
	phead->prev = phead;
	return phead;//返回该指针地址
}




//链表打印
//思考：双链表的打印，由于其循环、带哨兵位的原因，需要确定何时停止，以及保证不打印出哨兵位的数据。
//故一个方法是用于遍历的指针初始时就指向哨兵位头结点后的首位有效结点，当遍历指针迭代更新，其指向哨兵位的头结点时，循环结束。
void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;//指向哨兵位后一结点：即不打印哨兵位数据
	while (cur != phead)//判断的条件：由于链表循环，最终会回到哨兵位
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}




//链表尾插
//思考：在先前写过的单链表中，两链表尾插需要二级指针，此处此类型的双链表中，链表尾插是否需要二级指针？
//此处双链表中，已经含有哨兵位的头，尾插只需要变动结点内部成员，不需要变动结点的地址。（即next、prev指针是结构体成员，因此函数传参时使用一级指针即可）
//细节：注意结点间指向关系的变动
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	//pos位置前插入函数作用于尾插：
	ListInsert(phead, x);//此处要注意phead->prev不是尾插

	//不借助Insert函数的写法：
	//新增结点
	LTNode* newnode = BuyListNode(x);
	//改变结点中指针指向关系
	LTNode* tail = phead->prev;//找到原先链表的尾结点
	//改变tail：
	tail->next = newnode;
	//改变newnod:
	newnode->prev = tail;
	newnode->next = phead;
	//改变phead:
	phead->prev = newnode;
}


//链表头插
//思考：带哨兵位的头插，需要理解此时头插的含义，哨兵位始终占据理论上的头结点不动，此处头插指的是在哨兵位后链表第二个结点前头插。
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	//pos位置前插入函数作用于头插：
	ListInsert(phead->next, x);

	//不借助Insert函数的写法：
	//新增结点
	LTNode* newnode = BuyListNode(x);
	//改变结点中指针指向关系
	LTNode* second = phead->next;//找到原链表中哨兵位后一个结点
	//改变second:
	second->prev = newnode;
	//改变newnode:
	newnode->next = second;
	newnode->prev = phead;
	//改变phead:
	phead->next = newnode;

	//若不使用second指针，改变结点指向关系时有顺序要求,以下为示范：
	LTNode* newnode = BuyListNode(x);
	newnode->next = phead->next;//此处出现phead->next，故需要放置在phead->next被修改之前
	newnode->prev = phead;
	phead->next->prev = newnode;//此处为了寻找second结点，故修改需要放置在phead->next被修改之前
	phead->next = newnode;
}



//辅助删除函数：用于判断链表是否为空（只剩带哨兵位的头结点时）
bool ListEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
	//若判等为真，返回ture，表示链表只剩哨兵位头；
	//若判等为假，返回false，表示链表中还有有效结点
}



//链表尾删
//思考：这种双向带头循环链表，就体现了尾删的好处，找尾时不必遍历。此处创建了一个tailprev，和上述头插中second一样，能够方便后续结点关系指向的修改。
//此方法对只有一个有效结点时仍旧适用，当链表为空时(只有哨兵位的头结点)，需要额外处理。
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));//其它写法：assert(phead->next!=phead);

	//借助Ereas函数的写法：(上述两句断言仍旧需要)
	ListErase(phead->prev);


	//不借助Erase函数的写法：
	//尾删，找尾结点,找尾删后的新尾结点
	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;
	//改变关系
	phead->prev = tail->prev;
	tailprev->next = phead;
	//释放待删除结点
	free(tail);
}


//链表头删
//思考：和头插一样要找准有效头结点以及删除后剩余结点间的指向关系
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

	//借助Ereas函数的写法：(上述两句断言仍旧需要)
	ListErase(phead->next);

	//不借助Erase函数的写法：
	//头删，有效头结点，新的有效头结点
	LTNode* second = phead->next;
	LTNode* secondnext = second->next;
	//改变指向关系
	phead->next = secondnext;
	secondnext->prev = phead;
	//释放结点
	free(second);
}





//pos位置前插入
//思考：带头双向链表，在pos位置前插入，prev指针的存在，不用遍历找pos位置
//关于pos位置如何得到：例如，使用ListFind函数找到链表中对应需要的结点，再在该结点前插入，或对该结点删除。
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	//确定指针
	LTNode* posprev = pos->prev;
	LTNode* newnode = BuyListNode(x);
	//修改关系
	//对newnode：
	newnode->next = pos;
	newnode->prev = posprev;
	//对pos：
	pos->prev = newnode;
	//对posprev：
	posprev->next = newnode;
}



//pos位置处删除
void ListErase(LTNode* pos)
{
	assert(pos);
	//确定所需指针：
	LTNode* posprev = pos->prev;
	LTNode* posnext = pos->next;
	//修改关系：
	posprev->next = posnext;
	posnext->prev = posprev;
	//删除结点：
	free(pos);
}



//求链表长度
//思路：遍历一遍计数,时间复杂度O(N)
int ListSize(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead;
	int size = 0;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}
//为使该函数和其它函数一样保持一致时间复杂度（即不遍历链表），
//一种方法是适用哨兵位的头结点中的data用来统计链表的长度，但此方法有bug，
//结构体中data类型为LTDataType,若为char类型，则存储结点有限，会溢出。（此方法在确定链表长度时可以选择性使用）
//实际要解决此问题，则使用结构体关联模式比较方便，或者可使用一个静态变量来完成




//链表销毁
void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		ListErase(cur);
		cur = next;
	}
	free(phead);
}

  
  

二、分块模式(附图)：

初始化

在这里插入图片描述

//辅助函数：动态开辟一个内存空间，新结点，可用于创建哨兵为的头、尾插、头插。
LTNode* BuyListNode(LTDataType x)
{
	//动态开辟:注意malloc的使用细节
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)//开辟失败
	{
		perror("malloc:fail");
		exit(-1);
	}
	//开辟成功时：
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

//链表初始化：双向链表、带头且循环
//参照之前的单链表，其若不带头也不循环，初始时链表为空，则指向NULL即可，
//但对于此双向链表，其带头、循环，因此但链表中无数据时，初始时要有一个哨兵位的头，且其前驱指针和后续指针都指向自己本身。
//细节：根据TestList1知，要改变实参本身（即链表指针），则此处链表初始函数化中，形参需要使用对应类型的二级指针。
void ListInitform(LTNode** pphead)
{
	*pphead = BuyListNode(-1);//初始时，链表中只有哨兵位的头结点
	(*pphead)->next = *pphead;//处理后续指针指向，使其指向自己
	(*pphead)->prev = *pphead;//处理前驱指针指向，使其指向自己
}

//链表初始化改进版
//由于上述链表初始化需要使用到二级指针，此处改进版是在只使用一级指针的情况下：相应的TestList中接收方法需要变动
LTNode* ListInit(void)
{
	LTNode *phead = BuyListNode(-1);//在初始化函数中创建一个新指针
	phead->next = phead;
	phead->prev = phead;
	return phead;//返回该指针地址
}

  
  

尾插

在这里插入图片描述

//链表尾插
//思考：在先前写过的单链表中，两链表尾插需要二级指针，此处此类型的双链表中，链表尾插是否需要二级指针？
//此处双链表中，已经含有哨兵位的头，尾插只需要变动结点内部成员，不需要变动结点的地址。（即next、prev指针是结构体成员，因此函数传参时使用一级指针即可）
//细节：注意结点间指向关系的变动
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	//pos位置前插入函数作用于尾插：
	ListInsert(phead, x);//此处要注意phead->prev不是尾插

	//不借助Insert函数的写法：
	//新增结点
	LTNode* newnode = BuyListNode(x);
	//改变结点中指针指向关系
	LTNode* tail = phead->prev;//找到原先链表的尾结点
	//改变tail：
	tail->next = newnode;
	//改变newnod:
	newnode->prev = tail;
	newnode->next = phead;
	//改变phead:
	phead->prev = newnode;
}

  
  

头插

在这里插入图片描述

//链表头插
//思考：带哨兵位的头插，需要理解此时头插的含义，哨兵位始终占据理论上的头结点不动，此处头插指的是在哨兵位后链表第二个结点前头插。
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	//pos位置前插入函数作用于头插：
	ListInsert(phead->next, x);

	//不借助Insert函数的写法：
	//新增结点
	LTNode* newnode = BuyListNode(x);
	//改变结点中指针指向关系
	LTNode* second = phead->next;//找到原链表中哨兵位后一个结点
	//改变second:
	second->prev = newnode;
	//改变newnode:
	newnode->next = second;
	newnode->prev = phead;
	//改变phead:
	phead->next = newnode;

	//若不使用second指针，改变结点指向关系时有顺序要求,以下为示范：
	LTNode* newnode = BuyListNode(x);
	newnode->next = phead->next;//此处出现phead->next，故需要放置在phead->next被修改之前
	newnode->prev = phead;
	phead->next->prev = newnode;//此处为了寻找second结点，故修改需要放置在phead->next被修改之前
	phead->next = newnode;
}

  
  

头插、尾插测试结果

在这里插入图片描述
  
  

尾删

在这里插入图片描述

//辅助删除函数
bool ListEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
	//若判等为真，返回ture，表示链表只剩哨兵位头；
	//若判等为假，返回false，表示链表中还有有效结点
}


//链表尾删
//思考：这种双向带头循环链表，就体现了尾删的好处，找尾时不必遍历。此处创建了一个tailprev，和上述头插中second一样，能够方便后续结点关系指向的修改。
//此方法对只有一个有效结点时仍旧适用，当链表为空时(只有哨兵位的头结点)，需要额外处理。
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));//其它写法：assert(phead->next!=phead);

	//借助Ereas函数的写法：(上述两句断言仍旧需要)
	ListErase(phead->prev);


	//不借助Erase函数的写法：
	//尾删，找尾结点,找尾删后的新尾结点
	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;
	//改变关系
	phead->prev = tail->prev;
	tailprev->next = phead;
	//释放待删除结点
	free(tail);
}

  
  

尾删测试结果

在这里插入图片描述
  
  

头删

在这里插入图片描述

//辅助删除函数
bool ListEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
	//若判等为真，返回ture，表示链表只剩哨兵位头；
	//若判等为假，返回false，表示链表中还有有效结点
}

//链表头删
//思考：和头插一样要找准有效头结点以及删除后剩余结点间的指向关系
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

	//借助Ereas函数的写法：(上述两句断言仍旧需要)
	ListErase(phead->next);

	//不借助Erase函数的写法：
	//头删，有效头结点，新的有效头结点
	LTNode* second = phead->next;
	LTNode* secondnext = second->next;
	//改变指向关系
	phead->next = secondnext;
	secondnext->prev = phead;
	//释放结点
	free(second);
}

  
  

头删测试结果

在这里插入图片描述
  
  

pos位置前插入

在这里插入图片描述


//pos位置前插入
//思考：带头双向链表，在pos位置前插入，prev指针的存在，不用遍历找pos位置
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	//确定指针
	LTNode* posprev = pos->prev;
	LTNode* newnode = BuyListNode(x);
	//修改关系
	//对newnode：
	newnode->next = pos;
	newnode->prev = posprev;
	//对pos：
	pos->prev = newnode;
	//对posprev：
	posprev->next = newnode;
}

  
  

pos位置处删除

在这里插入图片描述

//pos位置处删除
void ListErase(LTNode* pos)
{
	assert(pos);
	//确定所需指针：
	LTNode* posprev = pos->prev;
	LTNode* posnext = pos->next;
	//修改关系：
	posprev->next = posnext;
	posnext->prev = posprev;
	//删除结点：
	free(pos);
}

  
  

pos任意位置测试结果

在这里插入图片描述
  
  

  
  

图解无头单向非循环链表和带头双向循环链表
zhaocx111222333的博客
01-17 808
图解无头单向非循环链表和带头双向循环链表单链表(单向不带头)数据节点和头结点新增节点函数和初始化基本操作1.尾插2.尾删3.头插4.头删5.任意位置新增节点6.任意位置删除7.寻找数据8.销毁链表带头双向循环链表数据节点和头节点新增节点函数和初始化基本操作(删除和增加)1.尾插2.尾删3.头插4.头删5.在任意位置删除6.在任意位置增加 链表是一种重要的数据结构,其概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链 接次序实现的 。 这里介绍两种链表: 无头单
【数据结构】- 复杂度、顺序表、链表
huang_ftpjh的博客
07-14 443
主要看课后习题 算法的设计要求包括，正确性、可读性、健壮性和效率与低储存量需求。 （要改代码，尽量用接口，有问题时，不要用那个类，加个类进去） 数据结构中，从逻辑上可以把数据结构分为 线性结构和非线性结构。 计算机算法指的是解决问题的有限步骤。 算法复杂度 3次循环就是 线性 线性表是一个有限序列，可以为空 线性表第一个元素没有直接前驱，最后一个元素没有直接后继 假设线性表有n个元素，如果在第i个位置插入一个新元素，需向后移动 n-i+1个元素 链式 优点： 插入和删除不需...
【ONE·Data || 带头双向循环链表】
上士闻道，勤而行之。觉纷扰则静坐，觉懒看书则且看书 ♪(´▽｀)
03-15 322
数据结构基础：理解带头双向链表，并尝试模拟实现。
Java实现带头结点的循环双链表
yunshangguafan的博客
06-04 326
最近又回顾了一下数据结构链表的实现，就随便写了一个带头结点的循环双链表的实现，如果有不当的地方，希望大家多多指教。 话不多说，代码走起 1. 准备gong
双向循环链表和内核链表
m0_64547558的博客
08-05 927
内核链表和双向循环链表
循环双链表的基本操作实现
YanMeiHe的博客
10-08 1333
用头插法建立带头结点的循环双链表并对已创建的双链表实现插入、删除、查找等基本操作。
【ONE·Data || 栈和队列】
上士闻道，勤而行之。觉纷扰则静坐，觉懒看书则且看书 ♪(´▽｀)
03-17 533
数据结构基础：理解学习栈、队列、循环队列，并尝试模拟实现。
Round4—链表（2）（双链表与循环链表）
你倒是敲代码鸭.
09-16 1521
声明：本博客的图片来自百度，如果侵权请联系我，我删掉。 知识点： 先顾名思义，自己理解一下双链表与循环链表吧，具体的知识点有点碎，下面咱们就题说。 练习题： 选择题： 2-1对于一非空的循环单链表，h和p分别指向链表的头、尾结点，则有：(2分) p->next == h p->next == NULL p == NULL p == h 解析： 单循环链表就是单向的循...
小菜鸡用C语言实现双向循环链表
z_l_h_z_l_h的博客
05-05 76
用C语言实现带头的双向循环链表的实现，提供初始化、增删查改、销毁等串口函数。优点：可以在任意一个数据的地方找到前一个和后一个数据，不用遍历整个链表。如果需要小菜鸡源代码点击这里。提示：以下是本篇文章正文内容，下面案例可供参考//开辟一个空间if (!newslnode)printf("申请空间失败\n");exit(-1);//初始化int main()test1();return 0;这次没有可以显示的测试结果，后面测试就不写main函数了。
循环链表与双向链表
水逝流年
04-21 2517
1、循环链表 循环链表也是一种链式存储结构，他的
【数据结构入门精讲 | 第四篇】考研408、企业面试表专项习题
等风来
12-23 2582
在带哨兵结点的双循环链表中，设链结点的后继指针域为next，前驱指针域为prior，指针header指向哨兵结点，则判断该链表是否为空的表达式为：header->next==header 或 header->prior==header
数据结构--顺序表&链表
imp0128的博客
07-26 409
数据结构--顺序表&链表1.线性表2.顺序表2.1概念及基本结构2.2 接口实现 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以顺序结构和链式结构的形式存储。 特征： 对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型； 数据元素之间具有一
第二章作业题3-链表（2）
热门推荐
且听风吟
12-08 3万+
一、判断题 1-1 在具有N个结点的单链表中，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。 F 访问节点的时间复杂度为O(N) 1-2 若用链表来表示一个线性表，则表中元素的地址一定是连续的。F1-3 将长度分别为m,n的两个单链表合并为一个单链表的时间复杂度为O(m+n)。 F 时间复杂度为O(1)，如果是两个有序链表合成一个有序链表的时间复杂度为O(M + N)
SystemVerilog学习笔记（八）：循环
qq_38156104的博客
11-11 944
循环只不过是将需要多次运行的语句包含在循环中，而不是重复编写这些语句。循环将根据条件语句运行多次，如果条件始终为真，则它会变成无限循环，系统将挂起。
Redis简介、数据结构、高性能读写、持久化机制、分布式架构
weixin_42267411的博客
11-14 1095
Redis简介、数据结构、高性能读写、持久化机制、分布式架构
数据结构-查找以及效率分析
dametime_的博客
11-11 287
将被查概率高的放到靠前位置,可以提高查找成功的效率,但对于查找失败的情况需要从头看到尾,因为无序排列,根据实际情况选择不同的方式,经常查找成功可以考虑上图方式。折半查找的查找效率,绿色节点为查找成功,紫色为查找失败,一共11个结点,每一层结点的数量*查到该层结点需要的步数的综合/11就是成功的ASL,失败同理。因为右子树的节点数一定比左子树多1个或等于左子树的结点,所以当两个数折半查找,画出查找判断树,2结点在右子树。所以要想算出他们的查找效率,我们需要画出来对应的查找判定树(根据折半查找的思想画图)
优先级队列-PriorityQueue
最新发布
qq_39203337的博客
11-14 306
无界队列，数据存储于内部数组中，数据采用堆(默认小顶锥)的组织形式。
数据结构-二叉树
wwwwwgery的博客
11-14 204
二叉树有左右儿子之分完美二叉树（满二叉树）除了最下面的没有儿子其他结点都有两个儿子，叶节点比较齐的，完全二叉树不是满二叉数允许缺失最后的结点满二叉树可以达到2^k-1边的总数=节点数-1。
Java中的排序算法：探索与比较
Java小吕布的博客
11-11 969
Java中的排序算法种类繁多，每种算法都有其独特的原理和性能特点。在选择排序算法时，我们需要根据具体的应用场景和数据特性来做出合适的选择。通过深入理解和比较这些排序算法，我们可以更好地掌握Java中的数据处理和分析技巧。
C语言面向对象设计：实现带头双向循环链表
资源摘要信息:"面向对象实现带头双向链表" 本资源包主要介绍了如何使用C语言实现面向对象编程思想来构建一个带有头结点的双向循环链表。在C语言中，虽然没有像Java或C++这样的显式的类和对象概念，但我们仍然可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值