【数据结构与算法】单链表的原理及C语言实现

已于 2024-04-26 17:01:35 修改
阅读量842 收藏 23
点赞数 26
分类专栏： 数据结构与算法 文章标签： c语言 数据结构 算法
于 2024-02-03 11:05:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46216674/article/details/135916779
版权

【数据结构与算法】单链表的原理及C语言实现

参考博文1：【数据结构与算法】程序内功篇三–单链表
参考博文2：链表基础知识详解（非常详细简单易懂）
参考博文3：关于链表，看这一篇就足够了！（新手入门）
参考博文4：单链表——单链表的定义及基本操作

链表的原理

链表含义
  由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。

单链表的特点：

  • 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此链表两个节点的存储空间不相邻。
  • 单链表是非随机的存储结构，即不能直接找到表中某个特定的结点。查找某个特定的结点时，需要从表头开始遍历，依次查找。
  • 对于每个链表结点，分为存放数据的数据域以及存放下个节点地址的地址域

链表节点的定义：

typedef int data_t;

//结点定义
typedef struct node{
	data_t data;		//结点数据域
	struct node *next;	//结点后继指针域
}listNode;

链表的基本属性设计

创建一个空链表

  通常会用头指针来标识一个单链表，头指针为NULL时表示一个空表。但是，为了操作方便，会在单链表的第一个结点之前附加一个结点，称为头结点。头结点的数据域可以不设任何信息，也可以记录表长等信息。头结点的指针域指向线性表的第一个元素结点。

创建空链表（头指针）主要分为：①申请节点内存空间  ②成员变量赋初始值  ③返回头节点 三大步骤：

  • 功能：创建一个空链表  node为虚拟头节点
  • 参数：void
  • 返回值：头节点地址
/*
功能：创建一个空链表  node为虚拟头节点
参数：void
返回值：头节点地址
*/
listNode* link_create()
{
	//申请内存空间
	listNode* node = (listNode *)malloc(sizeof(listNode));
	if(node == NULL){
		printf("link_create: malloc error\n");
		return NULL;
	}
	
	//链表成员变量赋值
	node->data = 0;
	node->next = NULL;
	
	//返回链表地址
	return node;
}

链表的遍历（显示数据）

第一步：输出第一个节点的数据域，输出完毕后，让指针保存后一个节点的地址

第二步：输出移动地址对应的节点的数据域，输出完毕后，指针继续后移

第三步：以此类推，直到节点的指针域为NULL

通过遍历链表读取链表的数据并显示：

  • 功能：显示链表数据
  • 参数：para： 链表头
  • 返回值：成功返回0   失败返回-1
/*
功能：显示链表数据
参数：para： 链表头   
返回值：成功返回0;    失败返回-1
*/
int link_show(listNode* head)
{
	//入口参数检查
	if(head == NULL)
		return -1;
	
	//遍历链表 
	while(head->next != NULL)
	{
		printf("%d ", head->next->data);
		head = head->next;
	}
	printf("\n");
	return 0;
}

释放链表内存空间

通过遍历链表节点，释放每个节点的内存空间

  • 功能：释放链表内存空间
  • 参数：para： 链表头
  • 返回值： NULL
/*
功能：释放链表内存空间
参数：para :链表头          
返回值： NULL
*/
listNode* link_free(listNode* head)
{
	//入口参数检查
	if(head == NULL){
		printf("list_insert: para error\n");
		return NULL;
	}
	
	//封装临时节点
	listNode *temp = head;
	while(head != NULL)
	{
		temp = head;
		//printf("free: %d\n", head->data);
		//这两行不能反 必须先指向下一个再释放当前地址
		head = head->next;	
		free(temp);
	}
	
	return NULL;
}

链表的基本操作设计（增删改查）

链表插入节点

同顺序表一样，向链表中增添元素，根据添加位置不同，可分为以下 3 种情况：

  • 插入到链表的头部（头节点之后），作为首元节点；
  • 插入到链表中间的某个位置；
  • 插入到链表的最末端，作为链表中最后一个数据元素；

虽然新元素的插入位置不固定，但是链表插入元素的思想是固定的，只需做以下两步操作，即可将新元素插入到指定的位置：

  • 将新结点的 next 指针指向插入位置后的结点；
  • 将插入位置前结点的 next 指针指向插入结点；

例如，我们在链表{1,2,3,4}的基础上分别实现在头部、中间部位、尾部插入新元素 5，其实现过程如下图 所示：

头插法程序设计：

  • 功能：链表头插法插入数据
  • 参数：para1：链表头    para2：插入的数据
  • 返回值：成功返回0;   失败返回-1
    /*
功能：链表头插法插入数据
参数：para1: 链表头  	para2: 插入的数据
返回值：成功返回0;    失败返回-1
*/
int link_push_front(listNode* head, data_t value)
{
	//入口参数检查
	if(head == NULL)
		return -1;
			
	//封装节点
	listNode* node = (listNode *)malloc(sizeof(listNode));
	if(node == NULL){
		printf("link_push_front malloc error\n");
		return -1;
	}
	
	//头插法
	node->data = value;			//插入行节点数据
	node->next = head->next;	//将新节点连接到原来的头
	head->next = node;			//更新链表头
	
	return 0;
}

任意位置插入元素程序设计：

  • 功能：在链表特定位置插入一个元素
  • 参数： para1:链表头    para2:插入的元素值    para3:特定位置的索引
  • 返回值： 失败返回-1    成功返回0
    /*
功能：在链表特定位置插入一个元素
参数：	para1:链表头	para2:插入的元素值	para3:特定位置的索引
返回值： 失败返回-1    成功返回0
*/
int list_insert(listNode* head, data_t value, int index)
{
	//入口参数检查
	if(head == NULL || index < 0){
		printf("list_insert: para error\n");
		return -1;
	}
	//封装节点
	listNode* node = (listNode *)malloc(sizeof(listNode));
	if(node == NULL){
		printf("link_push_front malloc error\n");
		return -1;
	}
	node->data = value;
	
	//遍历到目标索引处
	int pos = 0;
	while(pos < index && head->next != NULL)
	{
		pos++; 
		head = head->next;
	}
	
	//索引过大
	if(head->next == NULL && index - pos > 0){
		printf("index invalid\n");
		return -1;
	}
	
	//插入数据
	node->next = head->next;
	head->next = node;
	
	return 0;
}

尾插法程序设计：

  • 功能：链表尾插法插入数据
  • 参数：para1： 链表头    para2：插入的数据
  • 返回值：成功返回0;     失败返回-1
    /*
功能：链表尾插法插入数据
参数：para1: 链表头    para2: 插入的数据
返回值：成功返回0;     失败返回-1
*/
int link_push_back(listNode* head, data_t value)
{
	//入口参数检查
	if(head == NULL)
		return -1;
		
	//封装节点
	listNode *node = (listNode *)malloc(sizeof(listNode));
	if(node == NULL){
		printf("link_push_back malloc error\n");
		return -1;
	}
	//新节点赋值
	node->data = value;
	node->next = NULL;
	
	//遍历链表 
	while(head->next != NULL)
	{
		head = head->next;
	}
	
	//尾插入节点
	head->next = node;
	
	return 0;
}

链表删除节点

  从链表中删除指定数据元素时，实则就是将存有该数据元素的节点从链表中摘除，但作为一名合格的程序员，要对存储空间负责，对不再利用的存储空间要及时释放。因此，从链表中删除数据元素需要进行以下 2 步操作：

  • 将结点从链表中摘下来;
  • 手动释放掉结点，回收被结点占用的存储空间;

其中，从链表上摘除某节点的实现非常简单，只需找到该节点的直接前驱节点 temp，执行一行程序：

temp->next = temp->next->next;

根据数据值删除某个节点

  • 功能：根据数据值 删除某个节点
  • 参数： para1:链表头  para2:删除数值
  • 返回值： 失败返回-1  成功返回0
    /*
功能：根据数据值 删除某个节点
参数：	para1:链表头	para2:删除数值
返回值： 失败返回-1    成功返回0
*/
int list_delete_val(listNode* head, int val)
{
	//入口参数检查
	if(head == NULL){
		printf("list_insert: para error\n");
		return -1;
	}
	
	//遍历链表
	while(head->next != NULL && head->next->data != val)
	{
		head = head->next;
	}

	//链表中无该数据
	if(head->next == NULL && head->data != val){
		printf("no such value\n");
		return -1;	
	}
	
	listNode *temp = head->next;	//暂存需释放空间的节点
	head->next = head->next->next;	//跳跃拉链，即删除了中间节点
	free(temp);						//释放节点
	temp = NULL;					//避免野指针
	
	return 0;	
}

根据索引删除某个节点

  • 功能：根据索引 删除某个节点 (链表其实没有所谓的索引，即第几个节点-1)
  • 参数： para1：链表头   para2：删除的索引
  • 返回值： 失败返回-1    返回 0
    /*
功能：根据索引 删除某个节点 (链表其实没有所谓的索引，即第几个节点-1)
参数：	para1:链表头	para2:删除的索引
返回值： 失败返回-1    成功返回0
*/
int link_delete_index(listNode* head, int index)
{
	//入口参数检查
	if(head == NULL || index < 0){
		printf("link_delete_index: para error\n");
		return -1;
	}
	
	//遍历链表
	int pos = 0;
	while(pos < index && head != NULL)
	{
		//节点遍历完了
		if(head->next == NULL){	
			printf("index error\n");
			return -1;
		}
		pos++;					//索引
		head = head->next;		//指针偏移
	}
	//printf("data: %d\n", head->data);
	//判断后一个元素是否为空
	if(head->next == NULL)
	{
		printf("index error\n");
		return -1;
	}
	
	listNode *temp = head->next;	//暂存需释放空间的节点
	head->next = head->next->next;	//跳跃拉链，即删除了中间节点
	free(temp);						//释放节点
	temp = NULL;					//避免野指针
	
	return 0;	
}

链表查找节点

按数值查找：
  查找数据value在单链表link中的节点索引。
  算法思想：从单链表的第一个结点开始，依次比较表中各个结点的数据域的值，若某结点数据域的值等于value，则返回该节点的索引；若整个单链表中没有这样的结点，则返回-1。

  • 功能：查找某个元素的下标索引
  • 参数：para1:链表头 para2:查找的某个元素值
  • 返回值： 失败返回-1  成功返回元素的下标索引
/*
功能：查找某个元素的下标索引
参数：para1:链表头	para2:查找的某个元素值
返回值： 失败返回-1    成功返回元素的下标索引
*/
int list_search(listNode* head, data_t val)
{
	//入口参数检查
	if(head == NULL){
		printf("list_insert: para error\n");
		return -1;
	}
	
	//pos 记录下标位置
	int pos = -1;
	while(head->next != NULL)
	{
		pos++;
		if(head->next->data == val)	//判断是否存在val
			return pos;
		head = head->next;
	}
	return -1;
}

增删改查测试程序

//-------------测试程序-------------
void link_test()
{
	listNode *head = link_create();
	int data1[] = {-3, 2, 9, 5, 101};
	int data2[] = {4, 100, 0};
	
	//尾插法插入数据
	for( int i = 0; i < 5; i++)
		link_push_back(head, data1[i]);
	
	//头插法插入数据
	for( int i = 0; i < 3; i++)	
		link_push_front(head, data2[i]);
	
	//特定位置插入数据
	link_insert(head,66,1);
	
	//显示原链表
	printf("src link:");
	link_show(head);
	
	link_delete_index(head, 2);	//删除下标为2的节点
	link_delete_val(head, 66);	//删除数据为66的节点
	printf("delete:  ");
	link_show(head);
	
	//查找
	int ret = link_getVal( head, 2);
	int idx = link_search( head, 101);
	printf("data[2]: %d\n", ret);
	printf("101's index: %d\n", idx);
	
	head = link_free(head);	
}

链表的复杂操作程序设计

单链表的反转

算法思路: 依次取原链表中各结点，将其作为新链表首结点插入head结点
即获取原链表的每个节点，在新链表进行头插法插入：

  1. 判断是否为空 / 是否只有1个节点
  2. 断开链表，一分为二，分为第一个节点和后面链表
  3. 遍历从第二个后面起的节点，头插法循环插入

 

  • 功能：单链表的反转
  • 参数： para:   链表头
  • 返回值： 失败返回-1   成功返回0
int link_reverse(listNode* head)
{
	//入口参数检查
	if(head == NULL ){
		printf("head is NULL.\n");
		return -1;
	}
	
	//只有一个节点
	if(head->next == NULL || head -> next ->next == NULL ){
		return 0;
	}
	
	//p指向待操作的节点
	listNode *p = head->next->next;	//新链表头
	head->next->next = NULL;		//链表一分为二
	listNode *q = p;
	
	//遍历后续节点，以尾插法插入新的链表
	while(p != NULL)
	{
		q = p;
		p = p->next;
		
		//头插法 插入q
		q->next = head->next;
		head->next = q;
	}
	
	return 0;
}

测试程序：

void link_reverse_test()
{
	listNode *head = link_create();
	int data1[] = {-3, 2, 9, 5, 3};
	for(int i = 0; i < 5; i++)
		link_push_back(head, data1[i]);
		
	//打印原链表
	printf("link: ");
	link_show(head);
	
	//翻转链表
	link_reverse(head);
	
	//打印翻转后的链表
	printf("reverse: ");
	link_show(head);
	
	//释放内存空间
	head = link_free(head);
}

相邻节点最大值

算法思路： 设q，p分别为链表中相邻两结点指针，其中p在前，q在后，求q->data + q->data为最大的那一组值，返回其相应的指针q即可:

  1. 节点个数 <= 2，退出
  2. 初始化辅助变量（遍历节点指针p，q（p在前，q在后），两数之和sum，新节点指针ret指向head，并以头节点一分为二）
  3. 遍历p和q，以及sum

 

  • 功能：求相邻节点最大值，返回最大值第一个节点地址，最大值通过参数传递
  • 参数： para1:链表头 para2:最大和的值的地址
  • 返回值： 失败返回NULL 成功返回第一个节点指针
//求链表中相邻两节点data值之和为最大的第一节点的指针
/*
功能：求相邻节点最大值，返回最大值第一个节点地址
最大值通过参数传递
参数：	para1:链表头 	para2:最大和的值的地址
返回值： 失败返回NULL  成功返回第一个节点指针
*/
listNode *list_adjmax(listNode *head, data_t *value)
{
	if(head == NULL)
	{
		printf("head is NULL\n");
		return NULL;
	}
	
	if(head->next == NULL || head->next->next == NULL || head->next->next->next == NULL)
		return head;

	//构造辅助变量
	listNode *ret = head->next;			//结果链表尾指针
	listNode *p   = head->next->next;	//遍历链表的指针, p在前面
	listNode *q   = head->next;			//遍历链表的指针, q在后
	data_t max = q->data + p->data ;	//初始化两数之和
	
	
	while(p->next != NULL)
	{
		//p q更新
		p = p->next;
		q = q->next;
		
		//比较最大值
		if(q->data + p->data > max)
		{
			max = q->data + p->data;	//更新最大值
			ret = q;					//更新最大值第一个节点
		}
	}
	
	//返回相邻最大值的第一个节点指针，并通过参数传回最大值
	*value = max;
	return ret;
}

测试程序：

void list_adjmax_test()
{
	listNode *head = link_create();
	int data1[] = {-3, 2, 9, 5, 3};
	for(int i = 0; i < 5; i++)
		link_push_back(head, data1[i]);
		
	//打印原链表
	printf("link: ");
	link_show(head);
	
	//计算最大两数之和及第一个节点
	int sum;
	listNode *ret = list_adjmax(head, &sum);
	
	//打印新节点数及其两数最大之和
	printf("data: %d\nsum: %d", ret->data, sum);
	
	//释放内存空间
	head = link_free(head);	
}

有序链表的合并

算法思想： 设指针p、q分别指向表A和B中的结点，若p -> data <= q -> data，则p进入结果表，否则q结点进入结果表。

  1. 参数判断（链表是否为空）
  2. 分别将链表一分为二，p，q分别指向两个链表的新的头，结果存放在以ret为尾节点的链表中
  3. 通过p，q指针遍历两个链表，将小的数值插入到ret结果链表中形成新的合并链表
  • 功能：合并两个链表，合并至head1
  • 参数： para1: 链表1头节点  para2: 链表2头节点
  • 返回值： 失败返回 -1  成功返回 0
//合并两个有序链表
/*
功能：合并两个链表，合并至head1
参数：	para1:链表1头节点	para2:链表2头节点
返回值： 失败返回-1  成功返回0
*/
int link_merge(listNode *head1, listNode *head2)
{
	//入口参数检查
	if( head1 == NULL || head2 == NULL){
		printf("head1 || head2 error\n");
		return -1;
	}
	
	//变量初始化
	listNode *p = head1->next;
	listNode *q = head2->next;
	listNode *ret = head1;
	head1->next = NULL;
	head2->next = NULL;
	
	while(p != NULL && q != NULL)
	{
		if(p->data <= q->data)
		{
			ret->next = p;		//p接入ret链表
			p = p->next;		//更新p
			ret = ret->next;	//更新新表尾
			ret->next = NULL;	//置空新表尾
		}
		else
		{
			ret->next = q;		//q接入ret链表
			q = q->next;		//更新q
			ret = ret->next;	//更新新表尾
			ret->next = NULL;	//置空新表尾
		}
	}
	
	//把多的p或q接入到ret链表
	if( p != NULL)
		ret->next = p;
	if( q != NULL)
		ret->next = q;
		
	return 0;
}

测试程序：

void link_merge_test()
{
	listNode *head1 = link_create();
	listNode *head2 = link_create();
	int data1[] = {1, 2, 4, 6, 8};
	int data2[] = {2, 5, 6, 22, 96, 128};
	
	//插入数据
	for(int i = 0; i < 5; i++)
		link_push_back(head1, data1[i]);
		
	for(int i = 0; i < 6; i++)
		link_push_back(head2, data2[i]);	
	
	//打印原有序链表
	printf("link1: ");
	link_show(head1);
	printf("link2: ");
	link_show(head2);
	
	//合并
	printf("merge: ");
	link_merge(head1, head2);
	link_show(head1);
	
	//去重
	printf("purge: ");
	link_purge(head1);
	link_show(head1);
	
	head1 = link_free(head1);	
	head2 = link_free(head2);	
}

链表的排序

  • 如果链表为空或只有一个结点，不需要排序
  • 先将第一个结点与后面所有的结点依次对比数据域，只要有比第一个结点数据域小的，则交换位置 ，交换之后，拿新的第一个结点的数据域与下一个结点再次对比，如果比他小，再次交换，以此类推
  • 第一个结点确定完毕之后，接下来再将第二个结点与后面所有的结点对比，直到最后一个结点也对比完毕为止
int link_sort(listNode *head )
{
	//头节点为空
    if (head == NULL){
        printf("head is NULL\n");
        return -1;
    }
    //只有1个节点
    if (head->next == NULL){
        printf("only one node\n");
        return 0;
    }
    
    listNode *q, *p, temp;
    p = head->next;			//从第一个节点开始
    while (p->next != NULL)
    {
        q = p->next;		//q从基准元素的下个元素开始
        while (q != NULL)
        {
            if (p->data > q->data)	//后面的元素小
            {
            	//交换值
                temp = *q;			
                *q = *p;
                *p = temp;
				
				//交换地址
                temp.next = q->next;
                q->next = p->next;
                p->next = temp.next;
            }
            q = q->next;
        }
        p = p->next;
    }
    return 0;
}
不会编程的小江江
关注
  • 26
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构 C语言实现循环单链表的实例
01-01
数据结构 C语言实现循环单链表的实例 实例代码： //=========杨鑫========================// //循环单链表的实现 #include #include <stdlib> typedef int ElemType; //定义结点类型 typedef struct Node { ...
python - 链表遍历输出的3种方法
qq_30869745的博客
11-04 3870
使用yield & list def items(self): current=self.head while current !=None: yield current.data current=current.getNext() for i in range(5): myList.add(i) print(list(myList.items())) # [4, 3,
数据结构—递归运用之遍历输出链表中的各个节点
小虾米编程
07-03 6798
1.数据结构是递归的 某些数据结构本身具有递归的特性，则它们的操作可递归地描述 例如，对于链表，其结点 LNode的定义由数据域data和指针域next组成，而指针域next是一种指向LNode类型的指针，即 LNode的定义中又用到了其自身，所以链表是一种递归的数据结构。 对于递归的数据结构，相应算法采用递归的方法来实现特别方便。 2.遍历输出链表中各个结点的递归算法 算法步骤 ①如果...
浅谈链表（1）--链表的构建以及遍历输出
YG爱木木
06-14 1474
1.在学完c++的基本语法之后，可能我们在组织一类相似的数据时首先想到的就是数组，至于数组，它的大小在某种意义上还是固定的，即使是可以动态分配内存。（当然vector在一定程度上解决了这个问题，之所以说是一定程度上，是因为vector只是一个数组对象，它重载了[]运算符，才让我们感觉他比较像数组，实际是他不是一个数组。）而且，很多时候，我们需要在这个群体里面添加元素与删除元素，或者在内存已经受到限...
单链表的元素录入和遍历输出
Lucien的博客
03-28 7120
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; struct Student{ char Name[20];//在Student结构体中定义姓名成员 char Number[10];//在Student结构体中定义学号成员 struct Student *next;//在...
数据结构与算法（C语言版）之单链表
qq_41743824的博客
03-13 1827
单链表介绍 与线性表在内存中的储存结构不同（线性表在内存中是一块连续的空间），链表的存储结构是组成链表的数据元素在内存中既可以是连续的，也可以是不连续的。链表中的每个元素都应该包含两个信息：一个是储存数据的信息，即数据域；另一个为储存与之相连的元素的位置信息，即指针域。 而单链表指的是链表中的每个节点中只包含一个指针域。整个链表的存取必须从头指针开始，头指针指示链表中的第一个节点的储存位置（头指针不用存放数据）。由于最后一个元素没有其后继元素，因此最后一个元素的指针域应为...
数据结构 单链表的生成算法 c语言实现
06-21
数据结构 单链表的生成算法 c语言实现
数据结构C语言单链表上实现插入和删除的算法实验报告.docx
05-30
数据结构C语言单链表上实现插入和删除的算法实验报告.docx
c语言实现单链表 （数据结构与算法 严蔚敏版 作业）完整源码
04-24
c语言实现单链表 完整源码 ，内含测试代码，用 VS 、GCC 编译器 打开，直接可以运行 。代码详细说明地址：https://blog.csdn.net/weiweiliude2/article/details/138145964
经典数据结构算法c语言实现代码（大全）
12-11
N皇后问题回溯算法.txt ping.txt re.txt source.txt winsock2.txt ww.txt 万年历.txt 万年历的算法 .txt 乘方函数桃子猴.txt 乘法矩阵.txt 二分查找1.txt 二分查找2.txt 二叉排序树.txt 二叉树.txt ...
linux驱动-CCF-1 provider 注册时钟
2401_83458819的博客
04-24 416
struct clk_hw_onecell_data onecell 填充到struct of_clk_provider *cp 中的data。struct clk_hw 组成 struct clk_hw_onecell_data onecell。b. 调用 of_clk_add_hw_provider 根据 进一步生成of_clk_provider ，并添加到全局列表。void *data;//对应 clk_hw_onecell_data（包含clk provider 注册的所有数组）
【数据结构】三、栈和队列：2.顺序栈&共享栈（顺序栈的初始化，判空，进栈，出栈，读取栈顶，顺序栈实例）
来csdn只办三件事：开源！开源！还是***开源！
04-23 1143
因为顺序栈的缺点是栈的大小不可变，所以引出共享栈，两个栈共享一片空间。这片存储空间不单独属于任何一个栈，某个栈需要的多一点，它就可能得到更多的存储空间。两个栈的栈底在这片存储空间的两端，当元素入栈时，两个栈的栈顶指针相向而行。当他们下一个指针的位置在一起时，说明这个栈已经放满元素。C++是一门面向对象的高级语言，在我们编写代码中，常常离不开对对象的创建和清理对象资源。指向栈顶元素，一般存储的是数组的下标。top当前指向的位置是栈顶上面的一个没有元素的空位置。如果有abcde，5个元素，那么满栈top=4。
【Redis 开发】(Feed流的模式，GEO数据结构，BitMap,HyperLogLog)
最新发布
weixin_62513677的博客
04-27 565
如果我们需要统计UV值，我们可以使用HyperLogLog，它是从LogLog算法中派生出来的概率算法，用于确定非常大的集合的基数，但是它的单个存储的统计内存永远小于16kb，但是代价就是统计是概率性的有小于0.81%的误差，不过可以忽略。也叫做写扩散，发布的消息不需要写入到发件箱中，直接推送到被关注人的收件箱中并通过时间戳进行排序，延时低，但是比如说微博中的一些大V，粉丝人特别多，这样就会写很多。范围可以是圆形或矩形。:指定圆心、半径，找到该圆内包含的所有member，并按照与圆心之间的距离排序后返回。
数据结构中的串（String）：概念、操作和实际应用
JAZJD的博客
04-24 937
在计算机科学中，串 是由零个或多个字符组成的有限序列，是数据结构中常见的一种基本类型。它可以为空串，也可以是由字符组成的非空串。串通常用于表示文本数据，如文件内容、用户输入等，因此在算法和程序设计中占据着重要的地位。一个串可以是由字母、数字、符号等任意字符组成，字符的种类和个数没有固定限制。例如，"Hello, World!@#$%" 都是串的例子。串的重要性在于它是对文本数据进行处理和操作的基础，涉及字符串匹配、文本编辑、编译器设计等多个领域。因此，深入理解串的特性和操作对于程序设计人员至关重要。
数据结构-树和森林之间的转化
2302_80729149的博客
04-23 338
这里我们根据左儿子右爸爸的逻辑将每个子树转化为二叉树的形式，对于第一个树，b，c，d都是a的儿子，所以都放到a的左边，而bcd之间也是兄弟关系，一起放到右边，然后再将三个树转化完毕后依次相连，构成二叉树的形式。从树的二叉链表的定义可知，任何一棵和树对应的二叉树，其根节点的右子树必为空。这里我们举三个树，将这个由三个树组成的森林组成二叉树是这个样子的。下面我们说明一下详细过程，首先将每个树转化为二叉的状态，如图所示。
【大数据】LSM树，专为海量数据读写而生的数据结构
Joker_ZJN的博客
04-24 978
一文详聊LSM树这种专为海量数据读写而生的数据结构
C#基础之冒泡排序
AMrss的博客
04-27 207
排序初探。
使用指针实现常见排序算法选择排序，直接插入排序和冒泡排序
2302_80782671的博客
04-27 228
void insertSort(int * p,int n) /*直接插入排序*/void selectSort(int *p,int n) /*选择排序*/void bubbleSort(int *p,int n) /*冒泡排序/{ if(*(p+j)> *(p+j+1))/*交换逆序元素*//*将范围内最小元素交换到位置i*/
数据结构与算法c语言单链表
09-19
单链表是一种经典的链式存储结构，它由一个包含数据和指向下一个节点的指针的节点构成。单链表的创建有头插法和尾插法两种方法。头插法将新创建的节点插入到头节点之后，而尾插法将新创建的节点插入到尾节点之后。以下是单链表的创建和增添数据的代码示例： ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node* next; } Node; Node* createLinkedList() { Node* head = NULL; return head; } void insertNode(Node** head, int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; if (*head == NULL) { *head = newNode; } else { Node* temp = *head; while (temp->next != NULL) { temp = temp->next; } temp->next = newNode; } } ``` 以上是单链表的创建和增添数据的代码实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不会编程的小江江

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

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

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

打赏作者

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

抵扣说明：

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

余额充值