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

news2024/10/3 18:46:04

【前面使用的所有链表的定义在第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]

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1033423.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

3.wifi开发，网络编程

3.wifi开发，网络编程

网络协议栈LwIP WiFi UDP Clinet编程 WiFi UDP Server编程 WiFi TCP Client编程 WiFi TCP Server编程 一。LWIP原理介绍&#xff0c;API介绍&#xff0c;文件结构 1.Lwip支持的协议 2.API 3.文件结构 1.api目录&#xff1a;应用程序接口文件。 2.arch目录&#xff1a;与硬件和…
阅读更多...
[管理与领导-100]：管理者到底是什么？调度器？路由器？交换机？监控器？

[管理与领导-100]：管理者到底是什么？调度器？路由器？交换机？监控器？

目录 前言&#xff1a; 二层交换机 三层路由器 监视器&#xff08;Monitor&#xff09; 调度器 前言&#xff1a; 人在群体中&#xff0c;有点像设备在网络中&#xff0c;管理者到底承担什么的功能&#xff1f; 二层交换机 交换机是计算机网络中&#xff0c;用于连接多台…
阅读更多...
环状分组柱状图 Python

环状分组柱状图 Python

代码&#xff1a; import matplotlib.pyplot as plt import numpy as np# 数据 np.random.seed(123) group1 100 * np.random.rand(5) group2 100 * np.random.rand(5) group3 100 * np.random.rand(5) group4 100 * np.random.rand(5)groups [group1, group2, group3, g…
阅读更多...
SpringAOP补充-通知获取类型

SpringAOP补充-通知获取类型

JoinPoint 是 ProceedingJoinPoint 的父类。 getArgs()是JoinPoint获取原方法返回值的函数。 preceed()是ProceedingJoinPoint获取原方法返回值的函数。
阅读更多...
Qt5开发及实例V2.0-第十四章-Qt多国语言国际化

Qt5开发及实例V2.0-第十四章-Qt多国语言国际化

Qt5开发及实例V2.0-第十四章-Qt多国语言国际化 第14章 Qt 5多国语言国际化14.1 基本概念14.1.1 国际化支持的实现14.1.2 翻译工作&#xff1a;“*.qm”文件的生成 14.2 【实例】14.2.1 简单测试14.2.2 选择语言翻译文字 本章相关例程源码下载1.Qt5开发及实例_CH1401.rar 下载2.…
阅读更多...
基于Xml方式Bean的配置-命名空间种类

基于Xml方式Bean的配置-命名空间种类

Spring的标签 Spring的xml标签大体上分为两类&#xff0c;一种是默认标签&#xff0c;一种是自定义标签 默认标签&#xff1a;就是不用额外导入其它命名空间约束的标签&#xff0c;例如<bean>标签 标签作用 <beans> 一般作为xml配置根标签&#xff0c;其他标签都是…
阅读更多...
如何利用播放器节省20%点播成本

如何利用播放器节省20%点播成本

点播成本节省的点其实涉及诸多部分&#xff0c;例如&#xff1a;CDN、转码、存储等&#xff0c;而利用播放器降本却是很多客户比较陌生的部分。火山引擎基于内部支撑抖音集团相关业务的实践&#xff0c;播放器恰恰是成本优化中最重要和最为依赖的部分。 火山引擎的视频团队做了…
阅读更多...
基于复旦微的FMQL45T900全国产化ARM开发开发套件（核心板+底板）

基于复旦微的FMQL45T900全国产化ARM开发开发套件（核心板+底板）

TES745D是我司自主研制的一款基于上海复旦微电子FMQL45T900的全国产化ARM核心板&#xff08;模块&#xff09;。该核心板将复旦微的FMQL45T900&#xff08;与XILINX的XC7Z045-2FFG900I兼容&#xff09;的最小系统集成在了一个87*117mm的核心板上&#xff0c;可以作为一个核心模…
阅读更多...
JavaWeb开发-08-MySQL(三)

JavaWeb开发-08-MySQL(三)

一.多表查询 -- 多表查询: 数据准备 -- 部门管理 create table tb_dept(id int unsigned primary key auto_increment comment 主键ID,name varchar(10) not null unique comment 部门名称,create_time datetime not null comment 创建时间,update_time datetime not null comm…
阅读更多...
数据治理-重要图

数据治理-重要图

语境关系图 车轮图 六边形图
阅读更多...
LLMs之InternLM：InternLM-20B的简介、安装、使用方法之详细攻略

LLMs之InternLM：InternLM-20B的简介、安装、使用方法之详细攻略

LLMs之InternLM&#xff1a;InternLM-20B的简介、安装、使用方法之详细攻略 导读&#xff1a;2023年09月20日&#xff0c;由上海人工智能实验室等团队发布了InternLM-20B的大模型。它在OpenCompass提出的5个能力维度上(语言、知识、理解、推理、学科)全面领先于同规模开源模型&…
阅读更多...
华为数通方向HCIP-DataCom H12-831题库(单选题：121-140）

华为数通方向HCIP-DataCom H12-831题库(单选题：121-140）

第121题 在华为交换机上配置RADIUS服务器模板时，下列选项中哪些参数为可选的配置参数? A、认证服务器地址和端口 B、RADIUS自动探测用户 C、计费服务器地址和端口 D、Shared-key 答案： B 解析： 在华为交换机上配置 radius 服务器模板时，需要配置共享秘钥，认证服务器地址…
阅读更多...
保研CS/软件工程/通信问题汇总

保研CS/软件工程/通信问题汇总

机器学习 1.TP、TN、FP、FN、F1 2.机器学习和深度学习的区别和联系 模型复杂性&#xff1a;深度学习是机器学习的一个子领域&#xff0c;其主要区别在于使用深层的神经网络模型。深度学习模型通常包含多个隐层&#xff0c;可以学习更加复杂的特征表示&#xff0c;因此在某些任…
阅读更多...
datax同步数据翻倍，.hive-staging 导致的问题分析

datax同步数据翻倍，.hive-staging 导致的问题分析

一、背景 有同事反馈 Datax 从 Hive 表同步数据到 Mysql 数据翻倍了。通过查看 Datax 任务日志发现&#xff0c;翻倍的原因是多读取了 .hive-staging_xx 开头的文件。接下里就是有关 .hive-staging 的分析。 二、环境 Hive 版本 2.1.1 三、分析 3.1 .hive-staging_hive 产…
阅读更多...
2023最新SSL证书在线申请系统源码 | 支持API接口

2023最新SSL证书在线申请系统源码 | 支持API接口

2023最新SSL证书在线申请系统源码 | 支持API接口 SSL证书保证网络安全的基本保障。向您介绍我们的在线生成SSL证书系统 支持在线生成SSL证书系统&#xff0c;用户登录可在线申请SSL&#xff0c;后台对接ssl证书API接口 测试运行环境&#xff1a;NginxPHP8.0MySQL5.7 源码下…
阅读更多...
【计算机网络】图解路由器（二）

【计算机网络】图解路由器（二）

本系列包含&#xff1a; 图解路由器&#xff08;一&#xff09;图解路由器&#xff08;二&#xff09; 图解路由器&#xff08;二&#xff09; 21、什么是静态路由&#xff1f;22、什么是动态路由&#xff1f;23、动态路由有哪些类型&#xff1f;24、什么是 RIP &#xff1f;2…
阅读更多...
【Spring中的设计模式】

【Spring中的设计模式】

文章目录 Spring中的设计模式1.控制反转(IoC)和依赖注入(DI)2.工厂设计模式3.单例设计模式实现方式Spring中的单例模式 4.代理设计模式代理模式在 AOP 中的应用Spring AOP 和 AspectJ AOP 有什么区别? 5.模板方法6.观察者模式Spring 事件驱动模型中的三种角色事件角色事件监听…
阅读更多...
3、ARIMA序列预测Matlab代码、可视化（可做算法对比）

3、ARIMA序列预测Matlab代码、可视化（可做算法对比）

1、文件包中程序均收集、整理、汇总自网络。 2、文件包完整内容&#xff1a; 1&#xff09;【ARIMA-功能函数】仅包含一个ARIMA算法函数&#xff0c;需要调用到自己的程序中使用。 函数部分代码及预览图&#xff1a; function [result] ARIMA_algorithm(data, Periodicity,…
阅读更多...
实现YOLOv5封装成函数以供其他程序进行调用

实现YOLOv5封装成函数以供其他程序进行调用

import detect detect.UAPI(source"data/images") 通过在YOLOv5中的detect.py的代码中&#xff0c;对检测函数进行封装&#xff0c;之后其他代码通过已经封装好的函数进行调用&#xff0c;从而实现简单便捷的YOLOv5代码调用。 代码的主要修改部分就是如何detect.py…
阅读更多...
pytest之parametrize()实现数据驱动

pytest之parametrize()实现数据驱动

第一个参数是字符串&#xff0c;多个参数中间用逗号隔开 第二个参数是list,多组数据用元组类型;传三个或更多参数也是这样传。list的每个元素都是一个元组&#xff0c;元组里的每个元素和按参数顺序一一对应 传一个参数 pytest.mark.parametrize(‘参数名’&#xff0c;list)…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023