动态数组和链表

最新推荐文章于 2024-08-07 19:21:33 发布
最新推荐文章于 2024-08-07 19:21:33 发布
阅读量80 收藏
点赞数
文章标签： 链表 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43936465/article/details/130685896
版权

动态数组

  • 设计一个动态数据, 实现存储任意数据类型
  • 并有遍历, 插入, 删除数据等功能

动态数组的设计

动态数组结构体

// 动态数组结构体
struct dynamicArray
{
	// 真实在堆区开辟数组的指针
	void** pAddr;
	// 数组容量
	int m_Capacity;
	// 数组大小
	int m_Size;
};

初始化数组

// 初始化数组
// capacity: 数组的初始大小
struct dynamicArray* init_dynamicArray(int capacity)
{
	if (capacity <= 0)
	{
		return NULL;
	}

	struct dynamicArray* arr = malloc(sizeof(struct dynamicArray));
	if (arr == NULL)
	{
		return NULL;
	}

	// 给属性初始化
	arr->pAddr = malloc(sizeof(void*) * capacity);
	// 容量初始化
	arr->m_Capacity = capacity;
	// 大小初始化
	arr->m_Size = 0;

	return arr;
}

插入数据

// 插入数据
// arr: 动态数组地址
// data: 要插入的数据
// pos: 要插入的位置
void insert_dynamicArray(struct dynamicArray* arr, void* data, int pos)
{
	if (arr == NULL || data == NULL)
	{
		return;
	}

	if (pos < 0 || pos > arr->m_Size)
	{
		pos = arr->m_Size;
	}

	// 判断数组是否满了
	if (arr->m_Size == arr->m_Capacity)
	{
		// 1. 计算新空间大小
		int newCapacity = arr->m_Capacity * 2;

		// 2. 开辟新空间
		void** newSpace = malloc(sizeof(void*) * newCapacity);

		// 3. 将原来空间数据拷贝到新空间
		memcpy(newSpace, arr->pAddr, sizeof(void*)* arr->m_Capacity);

		// 4. 释放原来空间
		free(arr->pAddr);

		// 5. 更改指针指向
		arr->pAddr = newSpace;

		// 6. 更新新容量
		arr->m_Capacity = newCapacity;
	}

	// 将元素插入数组中指定位置

	// 将pos以后的元素往后移动
	for (int i = arr->m_Size-1; i >= pos; i--)
	{
		arr->pAddr[i + 1] = arr->pAddr[i];
	}
	
	// 将数据插入到指定位置
	arr->pAddr[pos] = data;

	//更新数组大小
	arr->m_Size++;
}

按照指定位置删除数组

// 按照指定位置删除数组
// pos : 指定的位置
void removeByPos_dynamicArray(struct dynamicArray* arr, int pos)
{
	if (arr == NULL)
	{
		return;
	}

	if (pos < 0 || pos > arr->m_Size - 1)
	{
		// 无效位置, return
		return;
	}
	
	// 删除指定位置元素, 从前往后移动
	for (int i = pos; i < arr->m_Size; i++)
	{
		arr->pAddr[i] = arr->pAddr[i + 1];
	}

	// 更新数组的大小
	arr->m_Size--;

}

按值比较删除数据

// 按值比较删除数据
void removeByValue_dynamicArray(struct dynamicArray* arr, void* data, int(*myCompare)(void*,void*))
{
	if (arr == NULL || data == NULL)
	{
		return;
	}

	for (int i = 0; i < arr->m_Size; i++)
	{
		if (myCompare(arr->pAddr[i],data))
		{
			removeByPos_dynamicArray(arr, i);
			break;
		}
	}
}

销毁数组

// 销毁数组
void destroy_dynamicArray(struct dynamicArray* arr)
{
	if (arr == NULL)
	{
		return;
	}

	// 内部维护在堆区数组指针相释放
	if (arr->pAddr != NULL)
	{
		free(arr->pAddr);
		arr->pAddr = NULL;
	}

	free(arr);
	arr = NULL;

}

测试

测试结构体类型

struct Person
{
	char name[64];
	int age;
};

回调函数

// 回调函数 打印输出
void printPerson(void* data)
{
	struct Person* p = data;
	printf("name: %s, age: %d\n", p->name, p->age);
}
// 回调函数 对比删除数据
int comparePerson(void* data1, void* data2)
{
	struct Person* p1 = data1;
	struct Person* p2 = data2;

	if (strcmp(p1->name,p2->name) == 0 && p1->age == p2->age)
	{
		return 1;
	}

	return 0;
}

测试主程序

// 测试动态数组
void test01()
{
	// 初始化动态数组
	struct dynamicArray* arr = init_dynamicArray(5);

	struct Person p1 = { "aaa",18 };
	struct Person p2 = { "bbb",19 };
	struct Person p3 = { "ccc",16 };
	struct Person p4 = { "ddd",13 };
	struct Person p5 = { "eee",14 };
	struct Person p6 = { "fff",20 };

	printf("插入前------数组的大小: %d\n", arr->m_Size);
	printf("插入前------数组的容量: %d\n", arr->m_Capacity);

	// 插入数据
	insert_dynamicArray(arr, &p1, 0);
	insert_dynamicArray(arr, &p2, 6);
	insert_dynamicArray(arr, &p3, 2);
	insert_dynamicArray(arr, &p4, 1);
	insert_dynamicArray(arr, &p5, -1);
	insert_dynamicArray(arr, &p6, 4);

	// aaa ddd bbb ccc fff eee
	foreach_dynamicArray(arr, printPerson);

	printf("插入后------数组的大小: %d\n", arr->m_Size);
	printf("插入后------数组的容量: %d\n", arr->m_Capacity);

	// 删除 "ddd" 
	removeByPos_dynamicArray(arr, 1);

	printf("删除ddd后的结果:\n");
	foreach_dynamicArray(arr, printPerson);

	printf("删除后------数组的大小: %d\n", arr->m_Size);
	printf("删除后------数组的容量: %d\n", arr->m_Capacity);


	// 删除 "ccc" 
	struct Person p = { "ccc",16 };
	removeByValue_dynamicArray(arr, &p, comparePerson);

	printf("删除ccc后的结果:\n");
	foreach_dynamicArray(arr, printPerson);

	printf("删除后------数组的大小: %d\n", arr->m_Size);
	printf("删除后------数组的容量: %d\n", arr->m_Capacity);

	// 测试销毁
	destroy_dynamicArray(arr);
	arr = NULL;
}

单向链表-传统版

链表设计

节点结构体

  • 数据域
  • 指针域
struct LinkNode
{
	//数据域
	void* data;
	// 指针域
	struct LinkNode* next;
};

链表结构体

  • 头节点
  • 链表长度
struct LList
{
	// 头节点
	struct LinkNode pHeader;
	// 链表长度
	int m_Size;
};

给到用户的是: void* 取别名 LinkList

typedef void* LinkList;

初始化链表

LinkList init_LinkList()
{
	// 分配内存
	struct LList* mylist = malloc(sizeof(struct LList));

	if (mylist == NULL)
	{
		return NULL;
	}

	// 给头节点属性初始化
	mylist->pHeader.data = NULL;
	mylist->pHeader.next = NULL;
	mylist->m_Size = 0;

	return mylist;
}

插入节点

void insert_LinkList(LinkList list, int pos, void* data)
{
	if (list == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}

	struct LList* mylist = list;

	if (pos < 0 || pos > mylist->m_Size )
	{
		// 无效位置
		pos = mylist->m_Size;
	}

	struct LinkNode* pCurrent = &mylist->pHeader;

	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}

	// 此时 pCurrent 就是插入位置的前驱节点

	// 创建新节点
	struct LinkNode* newNode = malloc(sizeof(struct LinkNode));
	newNode->data = data;
	newNode->next = NULL;

	// 建立节点之间的关系
	newNode->next = pCurrent->next;
	pCurrent->next = newNode;

	// 更新链表长度
	mylist->m_Size++;
}

遍历链表

void foreach_LinkList(LinkList list, void(*myPrint)(void*))
{
	if (list == NULL)
	{
		return;
	}

	// 还原真实链表
	struct LList* mylist = list;
	// 创建临时节点
	struct LinkNode* pCurrent = mylist->pHeader.next;
	for (int i = 0; i < mylist->m_Size; i++)
	{
		// 打印输出
		myPrint(pCurrent->data);
		pCurrent = pCurrent->next;
	}
}

按位置删除节点

void remove_LinkList (LinkList list , int pos)
{
	if (list == NULL)
	{
		return;
	}
	// 还原真实链表
	struct LList* mylist = list;

	if (pos < 0 || pos > mylist->m_Size - 1)
	{
		return;
	}

	// 创建临时节点
	struct LinkNode* pCurrent = &mylist->pHeader;

	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}
	
	// 此时pCurrent就是待删除节点的前驱节点

	struct LinkNode* pDel = pCurrent->next;
	// 更改指针指向
	pCurrent->next = pDel->next;
	// 释放待删除节点
	free(pDel);
	pDel = NULL;

	// 更新链表长度
	mylist->m_Size--;
}

按值删除节点

void removeByValue_LinkList(LinkList list, void* data,int(*myCompare)(void*, void*))
{
	if (list == NULL)
	{
		return;
	}

	if (data == NULL)
	{
		return;
	}

	// 还原真实链表
	struct LList* mylist = list;

	// 创建临时节点
	struct LinkNode* pCurrent = &mylist->pHeader;
	struct LinkNode* pDel = pCurrent->next;


	for (int i = 0; i < mylist->m_Size; i++)
	{
		if (myCompare(data,pDel->data))
		{
			// 找到了

			// 更改指针指向
			pCurrent->next = pDel->next;
			// 释放待删除节点
			free(pDel);
			pDel = NULL;

			// 更新链表长度
			mylist->m_Size--;

			break;
		}

		// 没找到,指针向后移动
		pCurrent = pCurrent->next;
		pDel = pCurrent->next;

	}
}

返回链表长度

int size_LinkList(LinkList list)
{
	if (list == NULL)
	{
		return;
	}

	struct LList* mylist = list;

	return mylist->m_Size;
}

清空链表

void clear_LinkList(LinkList list)
{
	if (list == NULL)
	{
		return;
	}

	// 将list还原真实链表结构体
	struct LList* mylist = list;

	struct LinkNode* pCurrent = mylist->pHeader.next;
	struct LinkNode* pNext = NULL;

	for (int i = 0; i < mylist->m_Size; i++)
	{
		pNext = pCurrent->next;

		free(pCurrent);
		pCurrent = pNext;
	}

	mylist->pHeader.next = NULL;

	mylist->m_Size = 0;

}

销毁链表

void destroy_LinkList(LinkList list)
{
	if (list == NULL)
	{
		return;
	}

	// 先清空链表
	clear_LinkList(list);

	// 再销毁链表
	free(list);
	list = NULL;
}

测试

测试结构体类型

struct Person
{
	char name[64];
	int age;
};

回调函数

// 回调函数 打印输出
void printPerson(void* data)
{
	struct Person* p = data;
	printf("name: %s, age: %d\n", p->name, p->age);
}
// 回调函数 对比删除数据
int comparePerson(void* data1, void* data2)
{
	struct Person* p1 = data1;
	struct Person* p2 = data2;

	if (strcmp(p1->name, p2->name) == 0 && p1->age == p2->age)
	{
		return 1;
	}

	return 0;
}

测试主程序

void test01()
{
	// 初始化链表
	LinkList mylist = init_LinkList();

	struct Person p1 = { "aaa",18 };
	struct Person p2 = { "bbb",19 };
	struct Person p3 = { "ccc",16 };
	struct Person p4 = { "ddd",13 };
	struct Person p5 = { "eee",14 };
	struct Person p6 = { "fff",20 };

	// 插入数据
	insert_LinkList(mylist, 0, &p1);
	insert_LinkList(mylist, 5, &p2);
	insert_LinkList(mylist, -1, &p3);
	insert_LinkList(mylist, 2, &p4);
	insert_LinkList(mylist, 1, &p5);
	insert_LinkList(mylist, -1 ,&p6);
	
	// 遍历链表 
	// aaa eee bbb ddd ccc fff
	foreach_LinkList(mylist, printPerson);
	printf("链表长度为: %d \n", size_LinkList(mylist));

	// 按位置删除节点
	printf("--------------\n");
	remove_LinkList(mylist, 1);
	foreach_LinkList(mylist,printPerson);
	printf("链表长度为: %d \n", size_LinkList(mylist));

	// 按值删除节点
	printf("--------------\n");
	struct Person pp = { "bbb",19 };
	struct Person p = { "aaa",18 };
	removeByValue_LinkList(mylist, &p, comparePerson);
	removeByValue_LinkList(mylist, &pp, comparePerson);
	foreach_LinkList(mylist, printPerson);
	printf("链表长度为: %d \n", size_LinkList(mylist));

	// 清空链表
	printf("--------------\n");
	clear_LinkList(mylist);
	foreach_LinkList(mylist, printPerson);
	printf("链表长度为: %d \n", size_LinkList(mylist));

	// 销毁链表
	destroy_LinkList(mylist);

}

单向链表-企业版

  • 节点结构体只维护指针区
  • 用户预留4个字节空间, 我们帮助连接数据

链表设计

节点结构体

  • 只维护指针域
struct LinkNode
{
	// 只维护指针域
	struct LinkNode* next;
};

链表结构体

  • 头节点
  • 链表长度
struct LList
{
	// 头节点
	struct LinkNode pHeader;
	// 链表长度
	int m_Size;
};

给到用户的是: void* 取别名 LinkList

typedef void* LinkList;

初始化链表

LinkList init_LinkList()
{
	struct LList* mylist = malloc(sizeof(struct LList));

	if (mylist == NULL)
	{
		return NULL;
	}

	mylist->m_Size = 0;
	mylist->pHeader.next = NULL;

	return mylist;
}

插入节点

// list : 链表地址
// pos : 要插入元素的位置
// data : 要插入数据的地址
void insert_LinkList(LinkList list , int pos, void* data)
{
	if (list == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}

	struct LList* mylist = list;

	if (pos < 0 || pos > mylist->m_Size-1)
	{
		pos = mylist->m_Size;
	}

	// 取出用户前四个字节空间
	struct LinkNode* myNode = data;

	// 找到待插入位置的前驱节点
	struct LinkNode* pCurrent = &mylist->pHeader;

	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}

	// 更改指针指向
	myNode->next = pCurrent->next;
	pCurrent->next = myNode;

	// 更新链表长度
	mylist->m_Size++;
}

遍历链表

void foreach_LinkNode(LinkList list, void(*myPrint)(void*))
{
	if (NULL == list)
	{
		return;
	}

	struct LList* mylist = list;

	struct LinkNode* pCurrent = mylist->pHeader.next;

	for (int i = 0; i < mylist->m_Size; i++)
	{
		// pCurrent 就是用户数据的首地址
		myPrint(pCurrent);
		pCurrent = pCurrent->next;
	}
}

按位置删除节点

void removeByPos_LinkList(LinkList list, int pos)
{
	if (list == NULL)
	{
		return;
	}

	struct LList* mylist = list;

	if (pos < 0 || pos > mylist->m_Size - 1)
	{
		return;
	}

	// 找到前驱节点
	struct LinkNode* pCurrent = &mylist->pHeader;

	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}

	// 记录待删节点的位置

	struct LinkNode* pDel = pCurrent->next;

	// 重新建立节点之间的关系
	pCurrent->next = pDel->next;

	//free(pDel);// 数据本身是用户的, 由用户自己管理释放

	// 更新链表长度
	mylist->m_Size--;
}

按值删除节点

void removeByValue_LinkList(LinkList list, void* data, int(*myCompare)(void* , void*))
{
	if (list == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}

	struct LList* mylist = list;

	struct LinkNode* pCurrent = &mylist->pHeader;
	struct LinkNode* pDel = pCurrent->next;

	for (int i = 0; i < mylist->m_Size; i++)
	{
		if (myCompare(pDel,data))
		{
			// 找到了
			// 重新建立节点关系
			pCurrent = pDel->next;
			// 更新链表长度
			mylist->m_Size--;
			break;
		}
		pCurrent = pDel;
		pDel = pCurrent->next;
	}
}

清空链表

void clear_LinkList(LinkList list)
{
	if (list == NULL)
	{
		return;
	}

	struct LList* mylist = list;

	struct LinkNode* pCurrent = mylist->pHeader.next;
	struct LinkNode* pNext = pCurrent->next;

	for (int i = 0; i < mylist->m_Size; i++)
	{
		pCurrent = NULL;
		pCurrent = pNext;
		pNext = pNext->next;
	}

	mylist->pHeader.next = NULL;

}

销毁链表

void destroy_LinkList(LinkList list)
{
	if (list == NULL)
	{
		return;
	}

	free(list);
	list = NULL;
}

测试

测试结构体类型

  • 预留前四个字节位置
struct Person
{
	//struct LinkNode node;
	int* a;
	char name[64];
	int age;
};

回调函数

// 回调函数 打印输出
void printPerson(void* data)
{
	struct Person* p = data;
	printf("name: %s, age: %d\n", p->name, p->age);
}
// 回调函数 对比删除数据
int comparePerson(void* data1, void* data2)
{
	struct Person* p1 = data1;
	struct Person* p2 = data2;

	if (strcmp(p1->name, p2->name) == 0 && p1->age == p2->age)
	{
		return 1;
	}

	return 0;
}

测试主程序

void test01()
{
	LinkList* mylist = init_LinkList();

	// 创建数据
	struct Person p1 = {NULL, "aaa",18 };
	struct Person p2 = {NULL, "bbb",19 };
	struct Person p3 = {NULL, "ccc",16 };
	struct Person p4 = {NULL, "ddd",13 };
	struct Person p5 = {NULL, "eee",14 };
	struct Person p6 = {NULL, "fff",20 };

	// 插入数据
	insert_LinkList(mylist, 0, &p1);
	insert_LinkList(mylist, -1, &p2);
	insert_LinkList(mylist, 3, &p3);
	insert_LinkList(mylist, 1, &p4);
	insert_LinkList(mylist, 3, &p5);
	insert_LinkList(mylist, 2, &p6);

	// 遍历数据
	// aaa ddd fff bbb eee ccc
	foreach_LinkNode(mylist, printPerson);
	printf("------------------\n");

	// 删除"ddd"节点
	removeByPos_LinkList(mylist, 1);
	foreach_LinkNode(mylist, printPerson);
	printf("------------------\n");

	// 删除"ccc"节点
	struct Person p = { NULL, "ccc",16 };
	removeByValue_LinkList(mylist, &p, comparePerson);
	foreach_LinkNode(mylist, printPerson);
	printf("------------------\n");

	// 清空链表
	clear_LinkList(mylist);

	// 销毁链表
	destroy_LinkList(mylist);
	mylist = NULL;

}
妄จุ๊บ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构动态数组实现链表
05-12
动态数组和链表虽然都是数据结构，但它们各自具有不同的特性和用途，理解它们之间的交互可以增强我们对数据结构设计的理解。 链表是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的引用。...
php数组和链表的区别总结
10-16
在本篇文章里小编给大家整理的是关于php数组和链表的区别的相关知识点内容，有需要的朋友们可以学习下。
C语言 -- 动态数组&链表
woshizuopie的博客
09-04 954
将数组开辟到堆区，实现动态扩展。① 用户的数据类型无法确定；② 用户的数据无法确定创建在堆区还是栈区；③ 不管数据在堆区还是栈上，都是在内存中，就会有地址，只需维护数据的地址就行。
顺序线性表——通过存放地址，实现顺序存储--C语言简单实现
孑澈的专栏
12-20 395
顺序线性表——通过存放地址，实现顺序存储--C语言简单实现
图说数据结构之线性表顺序存储
君乙的博客专栏
04-23 1218
本人在学习数据结构过程中的一点心得，与大家共享。 数据结构学习中，听课能理解，一写代码就抓耳挠腮，烫嘴的山芋，感觉无从下口。有些事情一画图就明白，所以通过图形理解和记忆是比较便捷的一种方法。本章先从最简单的线性表顺序存储图说一下。 一、本质还是数据结构 万事开头难，编程的开头就是怎样定义线性表的头结构。看图： 头结构 头结构一般包括： 容量capacity：线性表的容量，线性表能...
受限线性表--队列
kakaka666的博客
07-05 265
一、队列基本概念 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的t（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。 二、队列的顺序存储 基本概念：队列也是一种特殊的线性表；可以用线性表顺序存储来模拟队列。 代码如下： dynamicArray.h #pragma once #define _CRT_SECURE_NO_WARNINGS #include<stdi..
sizeof(void*)
weixin_33989058的博客
07-17 763
在vs中，Win32 和 X64 的结果不同： （1）Win32 平台结果是4 （2）X64平台结果是8 只要是指针，不只是void*，包括char* 或 int*，结果都是一样。 原因就是指针存放的是内存地址，所以Win32 索引32位地址（4字节），X64索引64位地址（8字节） 最后给一段干坏事的代码，很简单，但是...
动态数组和链表的复杂度分析 数组和链表.pdf
04-18
"动态数组和链表的复杂度分析" 动态数组和链表是数据结构中两个基本的数据结构，它们的复杂度分析是非常重要的。本文将从四个维度对动态数组和链表的复杂度进行分析，即最好情况复杂度、最坏情况复杂度、平均情况...
遍历数组和链表 数组和链表.pdf
04-18
遍历数组和链表 在计算机科学中，数组和链表是两种基本的数据结构，它们之间有着很大的不同，影响着程序的性能和效率。本文将从遍历数组和链表的角度，比较它们之间的差异，探讨数组和链表的优缺点，并分析为什么...
数组和链表的时间复杂度 (1) 数组和链表.pdf
04-18
数组和链表的时间复杂度 在计算机科学中，时间复杂度是衡量算法性能的重要指标之一。不同的数据结构在各种操作下的时间复杂度也各不相同。以数组和链表为例，我们可以看到它们在插入、删除、随机访问等操作中的时间...
sizeof(void*)的大小到底由何决定？（个人理解）
热门推荐
TTc 's share
03-24 1万+
由编译器产生的目标平台的指令集决定的。譬如说x86就是4，x64就是8. sizeof(void*)的含义就是获取一个指针的大小。 指针的本质就是内存地址，因此指针的大小和内存空间有关。 32位的机器内存空间是2G（windows系统），因此指针的大小必须是，凑个整数那就是32bit。 因此本质上说，sizeof(void*)和编译器目标平台的内存空间有关。
C语言总结之数据类型，sizeof，void*总结
wu5215080的专栏
08-27 4307
 数据类型 数据类型的本质 从编译器和内存的角度理解数据类型：   Int a 告诉C编译器给我分配四个字节的内存。 1、数据类型的本质：可理解为创建变量的模具，是固定大小内存的别名。 2、数据类型的作用： 3、求数据类型大小：sizeof() 注意：sizeof()是操作符（单目运算符），不是函数。Sizeof测量的实体大小
关于 sizeof(int)和 sizeof(void *)
qq_39457296的博客
11-30 2678
关于 sizeof(int)和 sizeof(void *) sizeof(int)表示int类型占用的字节数，与编译器有关 sizeof(void * )表示指针类型占用的字节数，指针的本质是地址，不管是什么类型的指针，只要是指针，不只是void*，包括char* 或 int*，结果都是一样。 原因就是指针存放的是内存地址，所以Win32 索引32位地址（4字节），X64索引64位地址（8字节） 那么声明不同类型的指针意义是什么？？答案是规定指针在内存中每次移动的字节数 ...
单链表-数据结构
qq_31804097的博客
08-07 141
【代码】单链表、双向带头循环链表-数据结构。
【数据结构-前缀哈希】力扣525. 连续数组
最新发布
sjsjs11的博客
08-07 141
将nums中的0全部替换成-1，然后定义一个哈希表group，键用来储存sum，值用来储存对应的前缀和的下标。当前计算前缀和sum的时候，如果前面有相同的前缀和，说明中间这个子段和为0，也就说明0和1的数量相等，所以这个时候。给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。来求这个子段的长度。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 320
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
从零开始学数据结构系列之第四章《迪杰斯特拉算法了解》
铁匠匠匠的博客
08-04 1115
1、先选定一个根结点，并选定一个数组，先确定未遍历前的初始距离，把距离最短的邻接结点选定为中间结点，并标记访问过，开始往下遍历，挨个访问那个中间结点的邻接结点。计算出根结点到中间结点+中间结点到新邻接结点的距离，作为新距离，对比新距离和旧距离，如果新距离大，则把新距离替换掉旧距离，否则不变。算法的基本思想是：从源点出发，每次选择离源点最近的一个顶点前进，然后以该顶点为中心进行扩展，最终得到源点到其余所有点的最短路径。2、一轮访问结束后，从未标记的结点中选定距离最短的，把它作为中间结点，继续往下访问。
数据结构第十讲：二叉树OJ题
2301_79761834的博客
08-04 704
数据结构第十讲：二叉树OJ题
初识集合和数据结构
m0_51821434的博客
08-03 875
这次文章就浅浅的介绍了一下数据结构的基础知识，集合的框架，算法的一些特性
动态数组和链表的区别
08-06
动态数组和链表是两种常用的数据结构，它们在存储和访问数据上有一些区别。 1. 存储方式：动态数组使用连续的内存块来存储数据，而链表使用节点通过指针链接来存储数据。 2. 插入和删除操作：对于动态数组，插入和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值