31.链表练习题（2）（王道2023数据结构2.3.7节16-25题）

已于 2023-09-23 10:06:02 修改
阅读量259 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2023-09-23 00:07:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54708219/article/details/133151369
版权

【前面使用的所有链表的定义在第29节】

试题16：两个整数序列A，B存在两个单链表中，设计算法判断B是否是A的连续子序列。

bool Pattern(LinkList L1,LinkList L2){
//此函数实现比较L1的子串中是否有L2
	LNode *p, *q;  //工作在L1,p记录L1子串的首元
	LNode *r;  //工作在L2
	p = L1->next;
	q = L1->next;
	r = L2->next;
	while(q!=NULL && r!=NULL){
		if(q->data == r->data){  //p指针不动，q,r指针后移
			q = q->next;
			r = r->next;
		}
		else{
			r = L2->next;  //L2指针归零
			p = p->next;  //L1指针后移
			q = p;
		}
	}
	if(r == NULL){
		return true;
	}
	else{
		return false;
	}
}

int main(){
	LinkList L1, L2;
	InitList(L1);
	Create(L1);
	PrintList(L1);
	InitList(L2);
	Create(L2);
	PrintList(L2);
	printf("%d",Pattern(L1,L2));
	return 0;
}

输出：

当前单链表的所有元素：[3] [1] [2] [5] [4]
当前单链表的所有元素：[1] [2]
1

当前单链表的所有元素：[1] [2] [3] [4] [5]
当前单链表的所有元素：[6] [7] [8]
0

试题17：设计一个算法判断带头结点的循环双链表是否对称。

这里需要重新书写双链表的结构体定义，不能采用29节的代码。完整代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAXSIZE 100
#define ElemType int
#define Status int

//循环双链表的数据结构，一个结点，两个指针分别指向前驱和后继。
typedef struct LNode
{
	ElemType data;
	struct LNode *next,*prior;
}LNode, *LinkList;

//初始化
int InitList(LinkList &L)
{
	L = (LNode *)malloc(sizeof(LNode));
	L->next = NULL;
	L->prior = NULL;
	return 1;
}

//输出
void PrintList(LinkList L)
{
	printf("当前单链表的所有元素：");
	LNode *p;
	p = L->next;
	while (p != L)
	{
		printf("[%d] ", p->data);
		p = p->next;
	}
	printf("\n");
}

//尾插法创建单链表
int Create(LinkList &L)
{
	int n, e;
	LNode *temp = L;//声明一个指针指向头结点，用于遍历链表 　　

	printf("请输入要输入元素的个数：");
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		LNode *a = (LNode*)malloc(sizeof(LNode));
		printf("请输入第%d元素的值：", (i));
		scanf("%d", &e);
		a->data = e;
		temp->next = a;
		a->next = NULL;
		a->prior = temp;
		temp = temp->next;
	}
	temp->next = L;
	L->prior = temp;
	return 1;
}

//插入元素
int InsertList(LNode *L, int i, ElemType e)
{
	LNode *p = L;
	int j = 0;
	while (p && (j < i - 1))  //寻找要插入位置的前驱结点，让p指向它
	{
		p = p->next;
		++j;
	}
	if (!p || j > i - 1) return 0;	//插入位置非法，返回0
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;  //创建一个新结点存放要插入的元素e
	s->next = p->next;  //把新结点的指针域指向p->next
	s->prior = p;
	p->next = s;  //把p->next指向要插入的新结点
	p = p->next;
	s = s->next;
	s->prior = p;
	return 1;
}

//删除元素
int DeleteList(LNode *L, int i)
{
	LNode *p = L;
	int j = 0;
	while (p->next && (j < i - 1))	//寻找要删除结点的前驱结点，让p指向它
	{
		p = p->next;
		++j;
	}
	if (!p->next || j > i - 1) return 0;  //删除位置非法，返回0
	LNode *q;
	q = p->next;  //暂存删除结点，以便随后释放
	p->next = q->next;	//把p->next指向p->next->next，即q->next
	q->next->prior = p;
	free(q);  //释放结点
	return 1;
}

//按值查找元素
int LocateElem(LNode *L, ElemType e)
{
	int i = 1;
	LNode *p = L->next;
	while (p!=L && p->data != e)		//从第一个结点开始，依次向后遍历比较
	{
		p = p->next;
		i++;
	}
	if(p)	return i;
	else	return 0;	
}

bool Symmetry(LinkList L){
//此函数实现判断循环双链表是否对称
	LNode *p, *q;
	p = L->next;  //第一个元素
	q = L->prior;  //最后一个元素
	while(p!=q&&p->next!=q){  //奇数个元素的结束条件：p=q,偶数个：p->next=q
		if(p->data == q->data){
			p = p->next;
			q = q->prior;
		}
		else
			return false;
	}
	return true;
}

int main(){
	LinkList L1;
	InitList(L1);
	Create(L1);
	PrintList(L1);
	printf("%d",Symmetry(L1));
	return 0;
}

输出：

当前单链表的所有元素：[1] [2] [3] [2] [1]
1

当前单链表的所有元素：[1] [2] [3] [3] [2] [1]
1

当前单链表的所有元素：[1] [2] [3] [4] [3] [3] [1]
0

试题18：有两个循环单链表，链表头指针分别是L1和L2，编写一个函数将链表L2链接到链表L1之后，要求链接后的链表仍保持循环链表形式。

这里同样不能直接采用29节的代码，不过在建立单链表的最后加一句temp=L即可。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAXSIZE 100
#define ElemType int
#define Status int

//循环单链表的数据结构，尾结点指针指向表头结点。
typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;

//初始化
int InitList(LinkList &L)
{
	L = (LNode *)malloc(sizeof(LNode));
	L->next = L;
	return 1;
}

//输出
void PrintList(LinkList L)
{
	printf("当前单链表的所有元素：");
	LNode *p;
	p = L->next;
	while (p != L)
	{
		printf("[%d] ", p->data);
		p = p->next;
	}
	printf("\n");
}

//尾插法创建单链表
int Create(LinkList &L)
{
	int n, e;
	LNode *temp = L;//声明一个指针指向头结点，用于遍历链表 　　

	printf("请输入要输入元素的个数：");
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		LNode *a = (LNode*)malloc(sizeof(LNode));
		printf("请输入第%d元素的值：", (i));
		scanf("%d", &e);
		a->data = e;
		temp->next = a;
		a->next = NULL;
		temp = temp->next;
	}
	temp->next = L;
	return 1;
}

//插入元素
int InsertList(LNode *L, int i, ElemType e)
{
	LNode *p = L;
	int j = 0;
	while (p && (j < i - 1))  //寻找要插入位置的前驱结点，让p指向它
	{
		p = p->next;
		++j;
	}
	if (!p || j > i - 1) return 0;	//插入位置非法，返回0
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;  //创建一个新结点存放要插入的元素e
	s->next = p->next;  //把新结点的指针域指向p->next
	p->next = s;  //把p->next指向要插入的新结点
	return 1;
}

//删除元素
int DeleteList(LNode *L, int i)
{
	LNode *p = L;
	int j = 0;
	while (p->next && (j < i - 1))	//寻找要删除结点的前驱结点，让p指向它
	{
		p = p->next;
		++j;
	}
	if (!p->next || j > i - 1) return 0;  //删除位置非法，返回0
	LNode *q;
	q = p->next;  //暂存删除结点，以便随后释放
	p->next = q->next;	//把p->next指向p->next->next，即q->next
	free(q);  //释放结点
	return 1;
}

//按值查找元素
int LocateElem(LNode *L, ElemType e)
{
	int i = 1;
	LNode *p = L->next;
	while (p!=L && p->data != e)		//从第一个结点开始，依次向后遍历比较
	{
		p = p->next;
		i++;
	}
	if(p)	return i;
	else	return 0;	
}

LinkList Link(LinkList L1,LinkList L2){
//此函数实现判断循环双链表是否对称
	LNode *p, *q;
	p = L1->next;  //L1工作指针
	q = L2->next;  //L2工作指针，首先找到L1，L2最后一个元素
	while(p->next!=L1){
		p = p->next;	
	}
	while(q->next!=L2){
		q = q->next;	
	}
	p->next = L2->next;
	q->next = L1;
	free(L2);
	return L1;
}

int main(){
	LinkList L1,L2;
	InitList(L1);
	Create(L1);
	PrintList(L1);
	InitList(L2);
	Create(L2);
	PrintList(L2);
	PrintList(Link(L1,L2));
	return 0;
}

输出：

请输入要输入元素的个数：4
请输入第1元素的值：1
请输入第2元素的值：2
请输入第3元素的值：3
请输入第4元素的值：4
当前单链表的所有元素：[1] [2] [3] [4]
请输入要输入元素的个数：5
请输入第1元素的值：5
请输入第2元素的值：6
请输入第3元素的值：7
请输入第4元素的值：8
请输入第5元素的值：9
当前单链表的所有元素：[5] [6] [7] [8] [9]
当前单链表的所有元素：[1] [2] [3] [4] [5] [6] [7] [8] [9]

试题19：不断输出并删除最小值结点。此题非常同试题4.略过。

试题20：设头指针为L的带有表头结点的非循环双向链表，其每个结点中除有prior（前驱指针），data（数据），next（后继指针）域外，还有一个访问频度域freq。在链表被启用前，其值均初始化为零。每当在连表中进行一次Locate(L,x)运算时，令元素值为x的结点中freq域的值增1，并使此链表中结点保持按访问频度非递增的顺序排列，同时最近访问的结点排在频度相同的结点的前面，以便使频繁访问的结点总是靠近表头。试编写符合上述要求的Locate(L,x)运算的算法，该运算为函数过程，返回找到结点的地址，类型为指针型。

思路：这题就调整指针。由于是双链表所以找前驱后继都很方便。重新书写双链表的结构体类型然后作答：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 100
#define ElemType int
#define Status int
 
//双链表带freq域的数据结构
typedef struct LNode
{
	ElemType data;
	int freq;
	struct LNode *next,*prior;
}LNode, *LinkList;
 
//初始化
int InitList(LinkList &L)
{
	L = (LNode *)malloc(sizeof(LNode));
	L->next = NULL;
	L->prior = NULL;
	return 1;
}
 
//输出
void PrintList(LinkList L)
{
	printf("当前链表的所有元素：");
	LNode *p;
	p = L->next;
	while (p != NULL)
	{
		printf("[%d]%d ", p->data,p->freq);
		p = p->next;
	}
	printf("\n");
}
 
//尾插法创建双链表
int Create(LinkList &L)
{
	int n, e;
	LNode *temp = L;//声明一个指针指向头结点，用于遍历链表 　　
 
	printf("请输入要输入元素的个数：");
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		LNode *a = (LNode*)malloc(sizeof(LNode));
		printf("请输入第%d元素的值：", (i));
		scanf("%d", &e);
		a->data = e;
		a->freq = 0;
		temp->next = a;
		a->prior = temp;
		a->next = NULL;
		temp = temp->next;
	}
	return 1;
}
 
//按位插入元素
int InsertList(LNode *L, int i, ElemType e)
{
	LNode *p = L;
	int j = 0;
	while (p && (j < i - 1))  //寻找要插入位置的前驱结点，让p指向它
	{
		p = p->next;
		++j;
	}
	if (!p || j > i - 1) return 0;	//插入位置非法，返回0
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;  //创建一个新结点存放要插入的元素e
	s->freq = 0;
	s->next = p->next;  //把新结点的指针域指向p->next
	p->next->prior = s;
	p->next = s;  //把p->next指向要插入的新结点
	s->prior = p;
	return 1;
}
 
//删除元素
int DeleteList(LNode *L, int i)
{
	LNode *p = L;
	int j = 0;
	while (p->next && (j < i - 1))	//寻找要删除结点的前驱结点，让p指向它
	{
		p = p->next;
		++j;
	}
	if (!p->next || j > i - 1) return 0;  //删除位置非法，返回0
	LNode *q;
	q = p->next;  //暂存删除结点，以便随后释放
	p->next = q->next;	//把p->next指向p->next->next，即q->next
	q->next->prior = p;
	free(q);  //释放结点
	return 1;
}
 
//按值查找元素
int LocateElem(LNode *L, ElemType e)
{
	int i = 1;
	LNode *p = L->next;
	LNode *q;  //q用来向前遍历，寻找比其freq值大的结点
	while (p&&p->data != e)  //从第一个结点开始，依次向后遍历比较
	{
		p = p->next;
		i++;
	}
	if(p){
		p->freq ++;
		q = p;
		while(q->freq <= p->freq && q!=L){
			q = q->prior;
		}
		p->prior->next = p->next;
		p->next->prior = p->prior;
		p->next = q->next;
		p->prior = q;
		q->next = p;
		p->next->prior = p;
		return i;
	}
	else
		return 0;
}

int main(){
	LinkList L;
	InitList(L);
	Create(L);
	PrintList(L);
	printf("查找的元素在第%d位\n",LocateElem(L, 2));
	PrintList(L);
	printf("查找的元素在第%d位\n",LocateElem(L, 1));
	PrintList(L);
	printf("查找的元素在第%d位\n",LocateElem(L, 1));
	PrintList(L);
	return 0;
}

输出：

请输入要输入元素的个数：4
请输入第1元素的值：1
请输入第2元素的值：2
请输入第3元素的值：3
请输入第4元素的值：4
当前链表的所有元素：[1]0 [2]0 [3]0 [4]0
查找的元素在第2位
当前链表的所有元素：[2]1 [1]0 [3]0 [4]0
查找的元素在第2位
当前链表的所有元素：[1]1 [2]1 [3]0 [4]0
查找的元素在第1位

试题21：编写算法判断链表是否有环。

暴力解：首先从头节点开始，依次遍历单链表的每一个节点。每遍历到一个新节点，就从头节点重新遍历新节点之前的所有节点，用新节点ID和此节点之前所有节点ID依次作比较。如果发现新节点之前的所有节点当中存在相同节点ID，则说明该节点被遍历过两次，链表有环；如果之前的所有节点当中不存在相同的节点，就继续遍历下一个新节点，继续重复刚才的操作。

优解：快慢指针法。

//前面共同的部分省略，这里给出创建带环链表的函数，以及本题要求的函数FindLoopStart

//创建一个带环的链表
int Create_Loop(LinkList &L)
{
	int n, e;
	LNode *temp = L;  //声明一个指针指向头结点，用于遍历链表 　　
 
	printf("请输入要输入元素的个数：");
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		LNode *a = (LNode*)malloc(sizeof(LNode));
		printf("请输入第%d元素的值：", (i));
		scanf("%d", &e);
		a->data = e;
		temp->next = a;
		a->next = NULL;
		temp = temp->next;
	}
	temp->next = L->next->next;  //尾指针指向第2个结点，这样就有了环，这个函数建立的环的起始结点就是第2个
	return 1;
}

LinkList FindLoopStart(LinkList L){
	LNode *fast, *slow;
	fast = L;
	slow = L;
	while(fast!=NULL&&fast->next!=NULL){
		slow = slow->next;  //慢指针走一步
		fast = fast->next->next;  //快指针走两步
		if(fast==slow){  //快慢指针相遇，退出，这时候有环
			break;
		}
	}
	if(fast==slow){  //有环的情况，一个从表头开始，一个从上面的相遇点开始，再次相遇的时候就是环的起始点
		slow = L;
		while(fast!=slow){
			slow = slow->next;
			fast = fast->next;
		}
		printf("%d\n", fast->data);
		return fast;
	}
	else
		printf("链表无环\n");
		return NULL;  //无环，返回NULL
}
 
int main(){
	LinkList L1,L2;
	InitList(L1);
	Create(L1);  //无环链表
	PrintList(L1);
	InitList(L2);
	Create_Loop(L2);  //有环链表
	FindLoopStart(L1);
	FindLoopStart(L2);
	return 0;
}

输出：

链表无环
2

试题22：（2009年联考真题）

思路：设两个指针，一个指针先移动k，然后两个指针一起移动，最后第一个指针移到表尾第二个指针就是倒数第k个位置。

int Change(LinkList L,int k){
//此函数查找链表倒数第k个结点
	LNode *p, *q;
	p = L;
	q = L;
	for (int i = 0; i < k;i++){
		p = p->next;
		if(p == NULL)
			return 0;
	}
	while(p !=NULL){
		p = p->next;
		q = q->next;
	}
	printf("%d\n", q->data);
	return 1;
}
 
int main(){
	LinkList L;
	InitList(L);
	Create(L);
	PrintList(L);
	printf("%d",Change(L,3));
	return 0;
}

输出：

当前单链表的所有元素：[1] [2] [3] [4] [5]
3
1

当前单链表的所有元素：[1] [2] [3] [4] [5] [6]
4
1

当前单链表的所有元素：[1] [2]
0

试题23：（2012年联考真题）

这道题和前面题8完全一致（甚至这个题直接给了你拓扑结构，比题8还简单一些），可看上一节的解析。

试题24：（2015年联考真题）

此题的思路就是以空间换时间，因为题目中出现了\left | data \right |\leq n.

int abs(int n){
//此函数用来求绝对值
	if(n>0)
		return n;
	else
		return -n;
}

LinkList Delete(LinkList &L,int n){
//此函数对链表中绝对值相等的结点只保留第一个，删除之后所有绝对值相等的结点
	LNode *p, *q;
	p = L;
	q = L->next;
	int a[n + 1];  //辅助数组
	for (int i = 0; i < n + 1;i++){
		a[i] = 0;
	}
	while(q!=NULL){
		if(a[abs(q->data)]==0){
			a[abs(q->data)] = 1;
			p = p->next;
			q = q->next;
		}
		else{
			p->next = q->next;
			free(q);
			q = p->next;
		}
	}
	return L;
}
 
int main(){
	LinkList L;
	InitList(L);
	Create(L);
	PrintList(L);
	PrintList(Delete(L,5));
	return 0;
}

输出：

当前单链表的所有元素：[1] [-1] [2] [-2] [3]
当前单链表的所有元素：[1] [2] [3]

前单链表的所有元素：[1] [-4] [3] [2] [-1]
当前单链表的所有元素：[1] [-4] [3] [2]

试题25：（2019年联考真题）

此题分三步走：（1）找中间结点（2）把后半段逆置（3）从前后两段每次取一个结点重排

LinkList Change(LinkList &L){
//此函数对链表a1,a2...an变为a1,an,a2,an-1...
	LNode *p, *q, *r, *m;
	p = L;
	q = L;
	while(q!=NULL && q->next !=NULL){
		p = p->next;
		q = q->next->next;
	}
	//到此指针p就是我们找的中间结点，下面对p后面的部分做倒序，也就是头插法
	q = p->next;
	p->next = NULL;  //断链
	r = q->next;
	while(q!=NULL){
		q->next = p->next;
		p->next = q;
		q = r;
		if(r == NULL)
			break;
		r = r->next;
	}
	//到此我们完成了后面序列的倒序操作，接下来从L和p分别输出。
	q = L->next;
	r = p->next;
	p->next = NULL;
	p = q->next;
	while(q!=NULL){
		q->next = r;
		if(r ==NULL)
			break;
		r = r->next;
		q = q->next;
		q->next = p;
		if(p==NULL)
			break;
		p = p->next;
		q = q->next;
	}
	return L;
}
 
int main(){
	LinkList L;
	InitList(L);
	Create(L);
	PrintList(L);
	PrintList(Change(L));
	return 0;
}

输出：

当前单链表的所有元素：[1] [2] [3] [4] [5]
当前单链表的所有元素：[1] [5] [2] [4] [3]

当前单链表的所有元素：[1] [2] [3] [4] [5] [6]
当前单链表的所有元素：[1] [6] [2] [5] [3] [4]
qq_54708219
关注
专栏目录
王道数据结构线性表链表综合应用题04
qq_42673689的博客
08-30 169
王道数据结构综合应用题03
王道上几道链表的小题（下）
weixin_45312990的博客
07-18 898
假设有两个按元素值递增次序排列的线性表，均以单链表形式存储，编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，要求利用原来两个单链表的结点存放归并后的单链表 void MergeList(Listlist &La, Listlist &Lb){ // pa指向链表A的第一个结点，pb指向A的第一个结点，链表A指控，作为结果链表 // 同步遍历链表A和B...
30.链表练习题（1）（王道2023数据结构2.3.7节1-15题）
qq_54708219的博客
09-20 373
如果不是，这时候执行Del(L->next, x)，如果第2个是被删掉的元素，进入if(L->next->data==x)分支，此时p=L实际上执行p=L->next，p指向了第2个被删除的结点；第2行L = L->next执行的是L->next=L->next->next，把首元结点的next域修改为指向第3个结点；试题14：设A和B是两个单链表（带头结点），其中元素递增有序，设计一个算法从A和B中公共元素产生单链表C，要求不破坏A，B的结点。试题6：有一个带头结点的单链表L，设计算法使其递增有序。
40.查找练习题（王道2023数据结构第7章）
qq_54708219的博客
10-25 364
在链表被启用前，其值均初始化为零。每当在连表中进行一次Locate(L,x)运算时，令元素值为x的结点中freq域的值增1，并使此链表中结点保持按访问频度非递增的顺序排列，同时最近访问的结点排在频度相同的结点的前面，以便使频繁访问的结点总是靠近表头。试编写符合上述要求的Locate(L,x)运算的算法，该运算为函数过程，返回找到结点的地址，类型为指针型。线性表中各结点检索概率不等时，可用如下策略提高顺序检索的效率：若找到指定的结点，则将该结点与前驱结点（若存在）交换，使得经常被检索的结点尽量位于表的前端。
个人C语言学习实录练习题-链表.数据结构.快速排序练习.rar
05-22
链表是一种重要的数据结构，在计算机科学中，特别是编程领域，有着广泛的应用。它与数组不同，数组中的元素在内存中是连续存储的，而链表的每个元素（节点）包含数据以及指向下一个节点的指针，这使得链表在动态添加...
个人C语言学习实录练习题-链表.数据结构.快速排序等.zip
05-22
快速排序等.zip”中，包含了关于C语言编程、数据结构以及算法的重要练习题，特别是链表和快速排序这两个核心主题。下面将详细阐述这两个知识点，以及它们在计算机科学中的重要性。 一、链表 链表是一种基础且重要的...
王道数据结构考研复习指导（2022年）-选择题(CSDN).pdf
12-28
数据结构是计算机科学中的核心课程，对于准备考研的学生来说，理解和掌握数据结构至关重要。本复习指导聚焦于2022年的考研选择题，涵盖了数据结构的基础概念和算法评估等相关知识。 1. 数据结构的基本概念： - ...
2.C-数据结构-线性表-链表源码
09-07
2.C-数据结构-线性表-顺序表源码
数据结构习题-数据结构习题-数据结构习题-数据结构习题
09-09
给定一个有序链表 L，其结点结构为 struct ListNode {int val; ListNode *next;}，请实现一个函数来删除链表中所有重复的元素，使得每个元素只出现一次，并且返回删除后的链表头。 解答过程： 1. 问题分析： o 输入...
14_L3缓存友好的数据结构
刘炫320的博客
09-11 690
老鸟：L3缓存是CPU缓存层次结构中的第三层，通常比L1和L2缓存大，但访问速度稍慢。L3缓存友好的数据结构设计旨在最大限度地减少缓存未命中，从而提升性能。菜鸟：那这些数据结构有什么特点呢？老鸟：主要特点是数据局部性好，也就是说，数据在内存中是连续存储的，这样能更好地利用缓存行。我们可以从一个简单的例子开始，比如数组和链表的对比。老鸟：总结一下，L3缓存友好的数据结构通过提升数据局部性来提高性能。常见的有数组、等。它们在大数据处理和高性能计算中非常有用。但在实际应用中，需要权衡性能、可维护性和具体需求。
21_动态规划与数据结构结合
刘炫320的博客
09-11 508
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 607
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
从头开始嵌入式第三十八天（数据结构 双向链表）
qq_64792908的博客
09-11 631
2. 相比单向链表，双向链表在某些操作上更加灵活，比如在删除节点时，可以快速找到前驱节点进行调整，而单向链表需要从头开始遍历才能找到前驱节点。1. 每个节点包含两个指针，分别指向直接前驱节点和直接后继节点。这使得在双向链表中可以双向遍历，既可以向前也可以向后查找节点。1. 插入操作：可以快速确定插入位置的前后节点，进行指针调整，实现高效的插入操作。1. 需要频繁进行前后遍历的场景，如文本编辑器中对字符的双向移动和操作。2. 删除操作：由于能够直接访问前驱节点，删除操作也更加方便快捷。
【Python】数据结构,链表,算法详解
2201_75415080的博客
09-09 1797
自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树"""案例: 自定义代码, 模拟链表.​背景:顺序表在存储数据的时候, 需要使用到连续的空间, 如果空间不够, 就会导致扩容失败, 针对于这种情况, 我们可以通过链表实现.链表在内存中存储的时候, 可以不是连续的空间, "有地儿就行", 所以: 增删相对更好操作.​。
数据结构——(java版）Map与Set
2301_77993957的博客
09-11 1123
哈希表是一种数据结构，其实现思想是基于通过数据的关键码与所存地址两者之间构建映射关系，能够一次直接从表中得到想要搜索的元素。数据的关键码与所存地址之间的关系由哈希函数实现，规则为：设定适合的哈希函数之后，输入的关键码通过哈希函数的计算得出所存的地址。由此构造出来的结构称为哈希表。哈希表相对于二叉搜索树以及其他查询方式，不需要与多个关键码比较，这极大提升了查询的效率。
数据结构：（牛客）CM11 链表分割
2303_81073778的博客
09-09 342
给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。现有一链表的头指针 ListNode*
数据结构 1
2401_83575662的博客
09-14 491
算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为 输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《程序员代码面试指南》。4.算法的效率衡量一个算法的好坏，要从它的程序的时间复杂度和空间复杂度两方面来分析。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。5.时间复杂度。
【JavaScript】数据结构之字典 & 哈希表
最新发布
票票的博客
09-14 492
数据结构之字典和哈希表
C语言数据结构1-6章练习题：时间复杂度、存储结构详解
本资源是一份针对C语言版数据结构课程的章节练习题，涵盖第一章至第六章的内容。以下是对其中部分内容的详细解析： 1. 单选题： - 第一题考察数组元素的内存引用，数组元素`a[i]`在C语言中的表示是通过指针间接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

qq_54708219

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

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

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

打赏作者

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

抵扣说明：

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

余额充值