严蔚敏数据结构题集 p18（2.25——2.30）（c语言代码实现）

news2025/1/13 13:48:57

目录

 2.25假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合(即同一表中的元素值各不相同),现要求另辟空间构成一个线性表C,其元素为A和B中元素的交集,且表C中的元素也依值递增有序排列。试对顺序表编写求C的算法。

2.26要求同2.25题。是对单链表编写求C的算法

2.27 对2.25题的条件作以下两点修改,对顺序表重新编写求得表C的算法(1)假设在同一表(A或B)中可能存在值相同的元素,但要求新生成的表C中的元素值各不相同;(2)利用A表空间存放表C。 

2.28 对2.25题的条件作以下两点修改,对单链表重新编写求得表C的算法(1)假设在同一表(A或B)中可能存在值相同的元素,但要求新生成的表C中的元素值各不相同;(2)利用A表空间存放表C。

2.29 已知A,B和C为三个递增有序的线性表,现要求对A表作如下操作:删去那些既在B表中出现又在C表中出现的元素。试对顺序表编写实现上述操作的算法,并分析你的算法的时间复杂度(注意:题中没有特别指明同一表中的元素值各不相同)。

2.30 要求同2.29题.试对单链表编写算法,请释放A表中的无用结点空间。

 2.25假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合(即同一表中的元素值各不相同),现要求另辟空间构成一个线性表C,其元素为A和B中元素的交集,且表C中的元素也依值递增有序排列。试对顺序表编写求C的算法。

本题代码如下

sqlist jiaoji(sqlist* a, sqlist* b)
{
	sqlist c; // 定义一个结构体变量，用于存储交集结果
	c.length = 0; // 初始化交集长度为0
	int i = 0; // 定义一个整型变量，用于遍历顺序表a
	int j = 0; // 定义一个整型变量，用于遍历顺序表b
	int k = 0; // 定义一个整型变量，用于记录交集元素在结果中的位置
	while (i < a->length && j < b->length) // 当两个顺序表都没有遍历完时，进行循环
	{
		if (a->s[i] == b->s[j]) // 如果顺序表a和b当前位置的元素相等
		{
			c.s[k++] = a->s[i++]; // 将该元素添加到交集结果中，并将交集长度加1
			j++; // 顺序表b的指针向后移动一位
		}
		else if (a->s[i] < b->s[j]) // 如果顺序表a当前位置的元素小于顺序表b当前位置的元素
		{
			i++; // 顺序表a的指针向后移动一位
		}
		else // 如果顺序表a当前位置的元素大于顺序表b当前位置的元素
		{
			j++; // 顺序表b的指针向后移动一位
		}
	}
	c.length = k; // 更新交集长度
	return c; // 返回交集结果
}

完整测试代码如下

#include<stdio.h>
#define Max 10
typedef struct sqlist
{
	int s[Max]; // 定义一个结构体数组，用于存储顺序表的元素
	int length; // 定义一个整型变量，用于存储顺序表的长度
}sqlist;
// 定义一个函数，用于求两个顺序表的交集
sqlist jiaoji(sqlist* a, sqlist* b)
{
	sqlist c; // 定义一个结构体变量，用于存储交集结果
	c.length = 0; // 初始化交集长度为0
	int i = 0; // 定义一个整型变量，用于遍历顺序表a
	int j = 0; // 定义一个整型变量，用于遍历顺序表b
	int k = 0; // 定义一个整型变量，用于记录交集元素在结果中的位置
	while (i < a->length && j < b->length) // 当两个顺序表都没有遍历完时，进行循环
	{
		if (a->s[i] == b->s[j]) // 如果顺序表a和b当前位置的元素相等
		{
			c.s[k++] = a->s[i++]; // 将该元素添加到交集结果中，并将交集长度加1
			j++; // 顺序表b的指针向后移动一位
		}
		else if (a->s[i] < b->s[j]) // 如果顺序表a当前位置的元素小于顺序表b当前位置的元素
		{
			i++; // 顺序表a的指针向后移动一位
		}
		else // 如果顺序表a当前位置的元素大于顺序表b当前位置的元素
		{
			j++; // 顺序表b的指针向后移动一位
		}
	}
	c.length = k; // 更新交集长度
	return c; // 返回交集结果
}
int main()
{
	sqlist a, b; // 定义两个顺序表变量a和b
	int i = 0; // 定义一个整型变量，用于遍历顺序表a和b
	a.length = 5; // 设置顺序表a的长度为5
	b.length = 5; // 设置顺序表b的长度为5
	printf("请输入A顺序表的元素："); // 提示用户输入顺序表a的元素
	for (i = 0; i < a.length; i++) // 遍历顺序表a
		scanf("%d", &a.s[i]); // 读取用户输入的元素并存储到顺序表a中
	printf("请输入B顺序表的元素："); // 提示用户输入顺序表b的元素
		for (i = 0; i < b.length; i++) // 遍历顺序表b
			scanf("%d", &b.s[i]); // 读取用户输入的元素并存储到顺序表b中
	sqlist c = jiaoji(&a, &b); // 调用函数求两个顺序表的交集，并将结果存储到变量c中
	printf("C顺序表中的元素："); // 提示用户输出交集结果
		for (i = 0; i < c.length; i++) // 遍历交集结果
			printf("%d ", c.s[i]); // 输出交集结果中的每个元素
	return 0; // 程序正常结束，返回0
}

测试结果如下

2.26要求同2.25题。是对单链表编写求C的算法

本题代码如下

linklist jiaoji(linklist* A, linklist* B)
{
	lnode* C = (lnode*)malloc(sizeof(lnode));
	C->next = NULL;
	lnode* ra = (*A)->next, * rb = (*B)->next;
	lnode* rc = C, * r;
	while (ra && rb)
	{
		if (ra->data == rb->data)
		{
			r = ra;
			ra = ra->next;
			rb = rb->next;
			rc->next = r;
			r->next = NULL;
			rc = r;
		}
		else if (ra->data < rb->data)
		{
			ra = ra->next;
		}
		else
		{
			rb = rb->next;
		}
	}
	return C;
}

完整测试代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode, * linklist;
int a[5] = { 1,2,3,4,5 };
int b[5] = { 3,4,5,6,7 };
int n = 5;
void buildlinklist(linklist* L, int str[])
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	int i = 0;
	lnode* s, * r = *L;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = str[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
linklist jiaoji(linklist* A, linklist* B)
{
	lnode* C = (lnode*)malloc(sizeof(lnode));
	C->next = NULL;
	lnode* ra = (*A)->next, * rb = (*B)->next;
	lnode* rc = C, * r;
	while (ra && rb)
	{
		if (ra->data == rb->data)
		{
			r = ra;
			ra = ra->next;
			rb = rb->next;
			rc->next = r;
			r->next = NULL;
			rc = r;
		}
		else if (ra->data < rb->data)
		{
			ra = ra->next;
		}
		else
		{
			rb = rb->next;
		}
	}
	return C;
}
void print(linklist* L)
{
	lnode* k = (*L)->next;
	while (k)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist A, B;
	buildlinklist(&A, a);
	printf("A单链表元素为：");
	print(&A);
	buildlinklist(&B, b);
	printf("\nB单链表元素为：");
	print(&B);
	linklist C = jiaoji(&A, &B);
	printf("\nC单链表元素为：");
	print(&C);
	return 0;
}

测试结果如下

2.27 对2.25题的条件作以下两点修改,对顺序表重新编写求得表C的算法
(1)假设在同一表(A或B)中可能存在值相同的元素,但要求新生成的表C中的元素值各不相同;
(2)利用A表空间存放表C。 

本题代码如下

sqlist jiaoji(sqlist* a, sqlist* b)
{
	int i = 0; // 定义一个整型变量，用于遍历顺序表a
	int j = 0; // 定义一个整型变量，用于遍历顺序表b
	int k = 0; // 定义一个整型变量，用于记录交集元素在结果中的位置
	int c[Max];
	for (i = 0; i < a->length; i++)
		c[i] = a->s[i];
	i = 0;
	while (i < a->length && j < b->length) // 当两个顺序表都没有遍历完时，进行循环
	{
		if (c[i] == b->s[j]) // 如果顺序表a和b当前位置的元素相等
		{
			a->s[k++] = c[i++]; // 将该元素添加到交集结果中，并将交集长度加1
			j++; // 顺序表b的指针向后移动一位
		}
		else if (c[i] < b->s[j]) // 如果顺序表a当前位置的元素小于顺序表b当前位置的元素
		{
			i++; // 顺序表a的指针向后移动一位
		}
		else // 如果顺序表a当前位置的元素大于顺序表b当前位置的元素
		{
			j++; // 顺序表b的指针向后移动一位
		}
	}
	a->length = k;
	return *a; // 返回交集结果
}

完整测试代码如下

#include<stdio.h>
#define Max 10
typedef struct sqlist
{
	int s[Max]; // 定义一个结构体数组，用于存储顺序表的元素
	int length; // 定义一个整型变量，用于存储顺序表的长度
}sqlist;
// 定义一个函数，用于求两个顺序表的交集
sqlist jiaoji(sqlist* a, sqlist* b)
{
	int i = 0; // 定义一个整型变量，用于遍历顺序表a
	int j = 0; // 定义一个整型变量，用于遍历顺序表b
	int k = 0; // 定义一个整型变量，用于记录交集元素在结果中的位置
	int c[Max];
	for (i = 0; i < a->length; i++)
		c[i] = a->s[i];
	i = 0;
	while (i < a->length && j < b->length) // 当两个顺序表都没有遍历完时，进行循环
	{
		if (c[i] == b->s[j]) // 如果顺序表a和b当前位置的元素相等
		{
			a->s[k++] = c[i++]; // 将该元素添加到交集结果中，并将交集长度加1
			j++; // 顺序表b的指针向后移动一位
		}
		else if (c[i] < b->s[j]) // 如果顺序表a当前位置的元素小于顺序表b当前位置的元素
		{
			i++; // 顺序表a的指针向后移动一位
		}
		else // 如果顺序表a当前位置的元素大于顺序表b当前位置的元素
		{
			j++; // 顺序表b的指针向后移动一位
		}
	}
	a->length = k;
	return *a; // 返回交集结果
}
int main()
{
	sqlist a, b; // 定义两个顺序表变量a和b
	int i = 0; // 定义一个整型变量，用于遍历顺序表a和b
	a.length = 5; // 设置顺序表a的长度为5
	b.length = 5; // 设置顺序表b的长度为5
	printf("请输入A顺序表的元素："); // 提示用户输入顺序表a的元素
	for (i = 0; i < a.length; i++) // 遍历顺序表a
		scanf("%d", &a.s[i]); // 读取用户输入的元素并存储到顺序表a中
	printf("请输入B顺序表的元素："); // 提示用户输入顺序表b的元素
	for (i = 0; i < b.length; i++) // 遍历顺序表b
		scanf("%d", &b.s[i]); // 读取用户输入的元素并存储到顺序表b中
	sqlist c = jiaoji(&a, &b); // 调用函数求两个顺序表的交集，并将结果存储到变量c中
	printf("交集存于A顺序表中的元素："); // 提示用户输出交集结果
	for (i = 0; i < c.length; i++) // 遍历交集结果
		printf("%d ", c.s[i]); // 输出交集结果中的每个元素
	return 0; // 程序正常结束，返回0
}

测试结果为

2.28 对2.25题的条件作以下两点修改,对单链表重新编写求得表C的算法
(1)假设在同一表(A或B)中可能存在值相同的元素,但要求新生成的表C中的元素值各不相同;
(2)利用A表空间存放表C。

本题代码如下

linklist Union(linklist* A, linklist* B)
{
	lnode* ra = (*A)->next, * rb = (*B)->next;
	(*A)->next = NULL;
	lnode* r = *A;
	while (ra && rb)
	{
		if (ra->data<rb->data)//若A中当前结点小于B中当前结点值
		{
			r->next = ra;
			r = ra;
			ra = ra->next;
			r->next = NULL;
		}
		else if (ra->data>rb->data)//若A中当前结点大于B中当前结点值
		{
			r->next = rb;
			r = rb;
			rb = rb->next;
			r->next = NULL;
		}
		else
		{
			r->next = ra;
			r = ra;
			ra = ra->next;
			rb= rb->next;
			r->next = NULL;
		}
	}
	r->next = NULL; //结果表的表尾结点置空
	return *A;
}

完整测试代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode, * linklist;
int na = 5;
int nb = 5;
int a[5] = { 1,3,5,7,9};
int b[5] = {1,2,3,4,5};
void buildlinklist(linklist* L, int arr[], int n)//创建链表
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	lnode* s = *L, * r = *L;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = arr[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
linklist Union(linklist* A, linklist* B)
{
	lnode* ra = (*A)->next, * rb = (*B)->next;
	(*A)->next = NULL;
	lnode* r = *A;
	while (ra && rb)
	{
		if (ra->data<rb->data)//若A中当前结点小于B中当前结点值
		{
			r->next = ra;
			r = ra;
			ra = ra->next;
			r->next = NULL;
		}
		else if (ra->data>rb->data)//若A中当前结点大于B中当前结点值
		{
			r->next = rb;
			r = rb;
			rb = rb->next;
			r->next = NULL;
		}
		else
		{
			r->next = ra;
			r = ra;
			ra = ra->next;
			rb= rb->next;
			r->next = NULL;
		}
	}
	r->next = NULL; //结果表的表尾结点置空
	return *A;
}
void print(linklist* L)//输出单链表
{
	lnode* k = (*L)->next;
	while (k)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist A, B;
	buildlinklist(&A, a, na);
	buildlinklist(&B, b, nb);
	printf("A链表为：");
	print(&A);
	printf("\nB链表为：");
	print(&B);
	linklist C = Union(&A, &B);
	printf("\n两个表元素交集的链表为：");
	print(&C);
	return 0;
}

2.29 已知A,B和C为三个递增有序的线性表,现要求对A表作如下操作:删去那些既在B表中出现又在C表中出现的元素。试对顺序表编写实现上述操作的算法,并分析你的算法的时间复杂度(注意:题中没有特别指明同一表中的元素值各不相同)。

本题代码如下

void delete_common_elements(int A[], int B[], int C[], int* lenA, int* lenB, int* lenC) 
{
    int i = 0, j = 0, k = 0;
    while (i < *lenA && j < *lenB && k < *lenC) 
    {
        if (A[i] == B[j] && A[i] == C[k])
        {
            for (int m = i; m < *lenA - 1; m++) 
            {
                A[m] = A[m + 1];
            }
            (*lenA)--;
        }
        else if (A[i] < B[j]) 
        {
            j++;
        }
        else if (A[i] < C[k])
        {
           k++;
        }
        else 
        {
            i++;
        }
    }
}

完整测试代码为

#include <stdio.h>
void delete_common_elements(int A[], int B[], int C[], int* lenA, int* lenB, int* lenC) 
{
    int i = 0, j = 0, k = 0;
    while (i < *lenA && j < *lenB && k < *lenC) 
    {
        if (A[i] == B[j] && A[i] == C[k])
        {
            for (int m = i; m < *lenA - 1; m++) 
            {
                A[m] = A[m + 1];
            }
            (*lenA)--;
        }
        else if (A[i] < B[j]) 
        {
            j++;
        }
        else if (A[i] < C[k])
        {
            k++;
        }
        else 
        {
            i++;
        }
    }
}
int main() {
    int A[] = { 1, 2, 3, 4, 5 };
    int B[] = { 2, 3, 4,5,6 };
    int C[] = { 3, 4, 5,6,7 };
    int lenA = sizeof(A) / sizeof(A[0]);
    int lenB = sizeof(B) / sizeof(B[0]);
    int lenC = sizeof(C) / sizeof(C[0]);
    delete_common_elements(A, B, C, &lenA, &lenB, &lenC);
    for (int i = 0; i < lenA; i++) {
        printf("%d ", A[i]);
    }
    return 0;
}

 测试结果为

2.30 要求同2.29题.试对单链表编写算法,请释放A表中的无用结点空间。

本题代码如下

void deleterepeat(linklist* A, linklist* B, linklist* C)
{
	lnode* ra = (*A)->next, *rb = (*B)->next, * rc = (*C)->next;
	lnode* r = *A,*q;
	while (ra&&rb&&rc)
	{
			if (ra->data == rb->data && ra->data == rc->data)
			{
				q = ra;
				r->next = ra->next;
				ra = ra->next;
				rb = rb->next;
				rc = rc->next;
                free(q);
			}
			else if(rb->data<ra->data)
			{
				rb = rb->next;
			}
			else if (rc->data < ra->data)
			{
				rc = rc->next;
			}
			else
			{
				r = ra;
				ra = ra->next;
			}
	}
}

完整测试代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode,*linklist;
int a[5] = { 2,3,4,5,6 };
int b[5] = { 3,4,5,6,7 };
int c[5] = { 1,2,3,4,5 };
int n = 5;
void buildlinklist(linklist* L,int str[])
{
	*L = (lnode*)malloc(sizeof(lnode));
	(*L)->next = NULL;
	lnode* s, * r = *L;
	int i = 0;
	for (i = 0; i < n; i++)
	{
		s = (lnode*)malloc(sizeof(lnode));
		s->data = str[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
void deleterepeat(linklist* A, linklist* B, linklist* C)
{
	lnode* ra = (*A)->next, *rb = (*B)->next, * rc = (*C)->next;
	lnode* r = *A,*q;
	while (ra&&rb&&rc)
	{
			if (ra->data == rb->data && ra->data == rc->data)
			{
				q = ra;
				r->next = ra->next;
				ra = ra->next;
				rb = rb->next;
				rc = rc->next;
                free(q);
			}
			else if(rb->data<ra->data)
			{
				rb = rb->next;
			}
			else if (rc->data < ra->data)
			{
				rc = rc->next;
			}
			else
			{
				r = ra;
				ra = ra->next;
			}
	}
}
void print(linklist* L)
{
	lnode* k = (*L)->next;
	while (k)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist A, B, C;
	buildlinklist(&A, a);
	buildlinklist(&B, b);
	buildlinklist(&C, c);
	deleterepeat(&A, &B, &C);
	printf("删除之后的A单链表中的元素为：");
	print(&A);
	return 0;
}

测试结果为

 

 

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

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

相关文章

03-IDEA集成Git,初始化本地库,添加远程仓库,提交,拉取,推送,分支的快捷操作

03-IDEA集成Git,初始化本地库,添加远程仓库,提交,拉取,推送,分支的快捷操作

IDEA集成Git 创建Git忽略文件 不同的IDE开发工具有不同的特点文件,这些文件与项目的实际功能无关且不参与服务器上的部署运行, 把它们忽略掉能够屏蔽之间的差异 局部忽略配置文件: 在本地仓库的根目录即项目根目录下直接创建.gitignore文件, 以文件后缀或目录名的方式忽略指定…
阅读更多...
CnosDB FDW：打通一扇通往PostgreSQL世界的大门

CnosDB FDW：打通一扇通往PostgreSQL世界的大门

本文档提供了下载、安装和使用 CnosDB FDW 的简要说明。请根据您的实际需求和环境对文档进行调整。 概述 CnosDB FDW 是一个用于在 PostgreSQL 数据库中访问 CnosDB 数据库的外部数据包装器&#xff08;Foreign Data Wrapper&#xff09;。它提供了在 PostgreSQL 中查询 CnosD…
阅读更多...
并发编程2：Java 加锁的原理和JVM对锁的优化

并发编程2：Java 加锁的原理和JVM对锁的优化

为什么要加锁 在多进程的环境下&#xff0c;如果一个资源被多个进程共享&#xff0c;那么对资源的使用往往会表现的随机和无序&#xff0c;这显然是不行的。例如多个线程同时对控制台输出&#xff0c;每个线程都输出的是完整的句子但是多个线程同时同时输出&#xff0c;则输出…
阅读更多...
sd_webui的实用插件，prompt/lama/human matting/...，持续开源更新！！

sd_webui的实用插件，prompt/lama/human matting/...，持续开源更新！！

热烈欢迎大家在git上star&#xff01;&#xff01;&#xff01;冲鸭&#xff01;&#xff01;&#xff01; 1.prompt优化插件 GitHub - leeguandong/sd_webui_beautifulprompt: beautifulprompt extension performs stable diffusion automatic prompt engineering on a bro…
阅读更多...
博途PLC数组指针应用(SCL)

博途PLC数组指针应用(SCL)

CODESYS数组类型变量使用介绍 https://rxxw-control.blog.csdn.net/article/details/131375218https://rxxw-control.blog.csdn.net/article/details/131375218 博途PLC数组类型变量使用介绍还可以查看下面文章博客： https://rxxw-control.blog.csdn.net/article/details/1…
阅读更多...
通义灵码简单使用例子

通义灵码简单使用例子

首先我们需要了解到通义灵码的能力&#xff1a; 行/函数级实时续写&#xff1a; 当我们在 idea进行代码编写时(确认开启了自动云端生成的模式)&#xff0c;通义灵码会根据当前代码文件及相关代码文件的上下文&#xff0c;自动为你生成代码建议。你可以不用&#xff0c;也可以t…
阅读更多...
Android把宽高均小于给定值的Bitmap放大到给定值，Kotlin

Android把宽高均小于给定值的Bitmap放大到给定值，Kotlin

Android把宽高均小于给定值的Bitmap放大到给定值&#xff0c;Kotlin 假设拉伸放大到SIZE2048 fun scaleSize(image: Bitmap): Bitmap {val w image.widthval h image.heightvar newW: Intvar newH: Intif (w > h) {newW SIZEnewH (SIZE / w.toFloat()) * h} else {newW …
阅读更多...
计算机网络TCP篇③问答篇

计算机网络TCP篇③问答篇

目录 一、如何理解 TCP 是面向字节流协议 先来说说为什么 UDP 是面向报文的协议&#xff1f; 如果收到了两个 UDP 报文&#xff0c;操作系统是如何区分开的呢&#xff1f; 再说说为什么 TCP 是面向字节流的协议&#xff1f; 二、如何解决粘包问题&#xff1f; ①、固定消…
阅读更多...
23.12.3日总结

23.12.3日总结

饿了么项目进度 新建菜品的添加属性&#xff1a; 适应不同尺寸的媒体查询&#xff1a; 菜品详细页面&#xff1a; 项目上遇到的问题 媒体查询遇到的问题&#xff1a; 关于媒体查询不能生效的原因-CSDN博客 答辩总结 js中声明变量的关键字&#xff08;const&#xff0c;let…
阅读更多...
前缀和例题:子矩阵的和AcWing796

前缀和例题:子矩阵的和AcWing796

//前缀和模板提,在读入数据的时候就可以先算好前缀和的大小 //计算前缀的时候用:g[i][j] g[i][j-1] g[i-1][j] - g[i-1][j-1] Integer.parseInt(init[j-1]); //计算结果的时候用:g[x2][y2] - g[x1 - 1][y2]- g[x2][y1-1] g[x1 -1][y1 - 1] "\n" //一些重复加的地…
阅读更多...
YOLOv8 区域计数 | 入侵检测 | 人员闯入

YOLOv8 区域计数 | 入侵检测 | 人员闯入

大家好，昨天的 YOLOv8 新增加了一个功能，区域计数，用这个功能我们能实现很多的任务， 比如入侵检测，流量统计，人员闯入等，使用方式也非常的方便，但是一定要使用最新版的 YOLOv8 代码（2023/12/03更新的代码）。 低版本是不具备这个功能的，上面是演示效果。 使用非常的方…
阅读更多...
InsCode实践分享

InsCode实践分享

在当今信息爆炸的时代&#xff0c;如何从海量信息中脱颖而出&#xff0c;获取更多的关注和认可&#xff0c;成为了许多人的共同追求。作为知乎平台上的优质用户&#xff0c;我愿意分享一些自己的经验和技巧&#xff0c;帮助大家更好地运用InsCode&#xff0c;实现个人成长和进步…
阅读更多...
细说CountDownLatch

细说CountDownLatch

CountDownLatch 概念 CountDownLatch可以使一个获多个线程等待其他线程各自执行完毕后再执行。 CountDownLatch 定义了一个计数器&#xff0c;和一个阻塞队列&#xff0c; 当计数器的值递减为0之前&#xff0c;阻塞队列里面的线程处于挂起状态&#xff0c;当计数器递减到0时…
阅读更多...
Linux下activemq的安装与安装成功确认

Linux下activemq的安装与安装成功确认

一、下载 apache-activemq-5.14.0-bin.tar.gz 二、安装 将压缩包拷入linux内&#xff0c;进行解压tar -zxvf apache-activemq-5.14.0-bin.tar.gz&#xff0c;与redis、nginx不同的是&#xff0c;active解压不需要安装就可以直接启动&#xff01; 启动命令&#xff1a;./bin…
阅读更多...
某60区块链安全之Create2实战二学习记录

某60区块链安全之Create2实战二学习记录

区块链安全 文章目录 区块链安全Create2实战二实验目的实验环境实验工具实验原理实验内容Create2实战二 实验步骤Create2实战二 实验目的 学会使用python3的web3模块 学会分析以太坊智能合约中的伪随机数问题 学会利用Create2可在同一地址部署不同合约特性解决伪随机数问题 找…
阅读更多...
❀My学习Linux命令小记录（6）❀

❀My学习Linux命令小记录（6）❀

目录 ❀My学习Linux命令小记录&#xff08;6&#xff09;❀ 26.ps指令 27.grep指令 28.awk指令 29.sed指令 30.wc指令 ❀My学习Linux命令小记录&#xff08;6&#xff09;❀ 26.ps指令 功能说明&#xff1a;报告当前系统的进程状态。 (ps.ps命令 用于报告当前系统的进…
阅读更多...
免费数据采集软件，多种数据采集方式

免费数据采集软件，多种数据采集方式

数据无疑是企业决策的关键驱动力。要充分利用数据&#xff0c;就需要进行数据收集&#xff0c;而数据采集的方式多种多样。 数据采集方式的丰富多彩 数据采集并非一蹴而就的简单任务&#xff0c;而是一个多层次、多步骤的过程。在这个过程中&#xff0c;我们有着多种数据采集…
阅读更多...
数据结构实验任务六 ：基于 Dijsktra 算法的最短路径求解

数据结构实验任务六 ：基于 Dijsktra 算法的最短路径求解

本次代码为实验六:基于 Dijsktra 算法的最短路径求解实现。本实验的重点在于对于Dijsktra算法的理解。有关Dijsktra的资料可以参考有关博文&#xff1a; 图论&#xff1a;Dijkstra算法——最详细的分析&#xff0c;图文并茂&#xff0c;一次看懂&#xff01;-CSDN博客 以下附上…
阅读更多...
[LeetCode周赛复盘] 第 374 场周赛20231203

[LeetCode周赛复盘] 第 374 场周赛20231203

[LeetCode周赛复盘] 第 374 场周赛20231203 一、本周周赛总结100144. 找出峰值1. 题目描述2. 思路分析3. 代码实现 100153. 需要添加的硬币的最小数量1. 题目描述2. 思路分析3. 代码实现 100145. 统计完全子字符串1. 题目描述2. 思路分析3. 代码实现 100146. 统计感冒序列的数…
阅读更多...
USART的PAL库编程

USART的PAL库编程

USART驱动的工作原理 总结一下我们之前使用中断的方式来进行数据的发送和接收 如果收到数据数据在RDR寄存器中 RXNE标志位就从0到1触发中断 进入中断服务函数 把数据缓存在队列中 然后在到进程函数中断接收数据函数中进行出队处理 发送数据就是把中断关闭&#xff08;标志位TXE…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023