顺序表实现(下)(C语言)

news2025/1/26 15:27:48

几道相关例题,帮助大家更好理解顺序表.

文章目录

前言

  • 一、顺序表
  • 二、创建顺序表并初始化
  • 三.删除非递减顺序表L中的重复元素
  • 四.在非递减顺序表中删除[s,t]之间的元素
  • 五.设计算法逆置顺序表L,并将序列L循环左移
  • 六.顺序表A和B的元素个数分别为m,n.A表升序排序,B表降序排序,两表中都不存在相同元素
  • 七.给定两个非空集合A和B,分别用升序顺序表La,Lb存储,设计算法求解A交B 
  • 八.给定两个非空集合A和B,分别用升序表La与Lb存储,设计算法求解A-B(A中元素减去B中有的元素)
  • 九.测试
  • 总结

前言

几道相关例题,帮助大家更好理解顺序表.

一、顺序表

typedef int Elemtype;
//顺序表的动态分配
typedef struct Sqlist {
	Elemtype* qlist;
	int length;
	int maxsize;
};
//定义打印顺序表函数
void print(Sqlist L) {
	for (int i = 0; i < L.length; i++) {//顺序遍历顺序表
		printf("%d ", L.qlist[i]);
	}

	printf("\n顺序表长度为:%d\n", L.length);
	printf("总大小为:%d\n", L.maxsize);
}

二、创建顺序表并初始化

//例1:定义创建顺序表并初始化函数
void InitSqlist(Sqlist& L) {//初始化空间为20,长度为15,{ 0,1,2,3,4,4,4,5,6,7,7,8,8,9,9 }
	L.maxsize = Max;
	L.length = 15;
	int arr[15] = { 0,1,2,3,4,4,4,5,6,7,7,8,8,9,9 };
	L.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (L.maxsize));
	for (int i = 0; i < L.length; i++) {
		L.qlist[i] = arr[i];
	}
}

 三.删除非递减顺序表L中的重复元素

//例6:删除非递减顺序表L中的重复元素
void deletesame(Sqlist &L) {
	int curlenth = 0;
	for (int i = 0; i < L.length; i++) {//每次区元素与新表最后一个元素进行比较如果不相等加入新表
		if (curlenth == 0 || L.qlist[i] != L.qlist[curlenth - 1]) {
			L.qlist[curlenth++] = L.qlist[i];
		}
	}
	L.length = curlenth;
}

四.在非递减顺序表中删除[s,t]之间的元素

//例7:在非递减顺序表中删除[s,t]之间的元素
void deletest2(Sqlist& L, int s, int t) {
	int curlength = 0;
	int i = 0;
	for (; i < L.length; i++) {//从前往后找第一个大于或等于s的元素的位置
		if (L.qlist[i] >= s) {
			break;
		}
	}
	curlength = i;
	i = L.length - 1;
	for (; i >= 0; i--) {//从后往前找第一个小于或等于t的元素的位置
		if (L.qlist[i] <= t) {
			break;
		}
	}
	i= i + 1;//指向下一个元素才是要复制的元素
	for (;  i< L.length; i++) {//复制元素
		L.qlist[curlength++] = L.qlist[i];
	}
	L.length = curlength;
}

 五.设计算法逆置顺序表L,并将序列L循环左移

//例8:设计算法逆置顺序表L,并将序列L循环左移
//定义逆置函数
void reverse1(Sqlist& L) {
	int low = 0;
	int high = L.length - 1;
	while (low < high) {//设置low和high指针对表中元素进行两两交换
		Elemtype tmp = L.qlist[low];
		L.qlist[low] = L.qlist[high];
		L.qlist[high] = tmp;
		low++;
		high--;
	}
}
void reverse2(Sqlist& L,int low ,int high) {
	while (low < high) {
		Elemtype tmp = L.qlist[low];
		L.qlist[low] = L.qlist[high];
		L.qlist[high] = tmp;
		low++;
		high--;
	}
}
void ROL(Sqlist &L, int r) {
	reverse2(L, 0, L.length - 1);//整体逆置
	reverse2(L, 0, r-1);//前r个元素逆置
	reverse2(L, r, L.length - 1);//后面元素逆置
}

 reverse1是直接将顺序表全部逆置,reverse2是给定起始和终止逆置.

顺序表的循环左移r位,就是先整体逆置,前r个元素逆置,后面元素逆置.

六.顺序表A和B的元素个数分别为m,n.A表升序排序,B表降序排序,两表中都不存在相同元素

(1)将两表合并,两表中元素都储存在C中

(2)表A有m+n个存储空间,将A,B两表合并所有元素都存储到A中

(3)对表A进行简单插入排序

//例9:顺序表A和B的元素个数分别为m,n.A表升序排序,B表降序排序,两表中都不存在相同元素
//(1)将两表合并,两表中元素都储存在C中
//创建La和Lb
void creatLaLb(Sqlist& La, Sqlist& Lb) {
	La.maxsize = 11;
	La.length = 6;
	int arr1[6] = { 0,2,4,7,8,9 };
	La.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (La.maxsize));
	for (int i = 0; i < La.length; i++) {
		La.qlist[i] = arr1[i];
	}
	Lb.maxsize = 11;
	Lb.length = 5;
	int arr2[5] = { 10,6,5,3,1 };
	Lb.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (Lb.maxsize));
	for (int i = 0; i < Lb.length; i++) {
		Lb.qlist[i] = arr2[i];
	}
}
//归并排序思想
void mergesort1(Sqlist& La, Sqlist& Lb, Sqlist& Lc) {
	int length = La.length + Lb.length;
	Lc.qlist = (Elemtype*)malloc(sizeof(Elemtype) * length);
	assert(Lc.qlist);
	Lc.maxsize = length;
	int curlength = 0;
	int i = 0;
	int j = Lb.length-1;
	while (i < La.length && j >=0) {
		if (La.qlist[i] > Lb.qlist[j]) {
			Lc.qlist[curlength] = Lb.qlist[j];
			curlength++;
			j--;
		}
		else {
			Lc.qlist[curlength] = La.qlist[i];
			curlength++;
			i++;
		}
	}
	while (i < La.length) {
		Lc.qlist[curlength++] = Lb.qlist[i];
		i++;
	}
	while (j >=0) {
		Lc.qlist[curlength++] = Lb.qlist[j];
		j--;
	}
	Lc.length = curlength;
}
//(2)表A有m+n个存储空间,将A,B两表合并所有元素都存储到A中
void mergesort2(Sqlist& La, Sqlist& Lb) {
	int curlength = 0;
	int i = La.length-1;//A表后
	int j = 0;//B表头
	while (i >= 0 && j < Lb.length) {//将A表与B表元素进行比较将大的存入A表后
		if (La.qlist[i] > Lb.qlist[j]) {
			La.qlist[La.maxsize - curlength - 1] = La.qlist[i];
			curlength++;
			i--;
		}
		else {
			La.qlist[La.maxsize - curlength - 1] = Lb.qlist[j];
			curlength++;
			j++;
		}
	}
	while (i >= 0) {//将A表剩余元素直接复制到A表中
		La.qlist[La.maxsize - curlength - 1] = La.qlist[i];
		curlength++;
		i--;
	}
	while (j < Lb.length) {//将B表剩余元素直接复制到A表中
		La.qlist[La.maxsize - curlength - 1] = Lb.qlist[j];
		curlength++;
		j++;
	}
	La.length = La.length + Lb.length;
}
//(3)对表A进行简单插入排序
void selectsort(Sqlist& L) {
	int i = 0;
	int j = 0;
	while (i < L.length) {//每次选取一个元素
		Elemtype e = L.qlist[i];
		j = i - 1;
		while (j >= 0 && e < L.qlist[j]) {//寻找插入位置
			L.qlist[j + 1] = L.qlist[j];
			j--;
		}
		L.qlist[j + 1] = e;
		i++;
	}
}

七.给定两个非空集合A和B,分别用升序顺序表La,Lb存储,设计算法求解A交B 

//例10:给定两个非空集合A和B,分别用升序顺序表La,Lb存储,设计算法求解A交B
//创建两个升序La表和Lb表
void creatLaLb2(Sqlist& La, Sqlist& Lb) {
	La.maxsize = 20;
	La.length = 11;
	int arr1[11] = { 1,1,2,2,3,3,4,4,5,5,6 };
	La.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (La.maxsize));
	for (int i = 0; i < La.length; i++) {
		La.qlist[i] = arr1[i];
	}
	Lb.maxsize = 20;
	Lb.length = 11;
	int arr2[11] = { 1,1,2,2,4,4,5,5,6,6,7 };
	Lb.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (Lb.maxsize));
	for (int i = 0; i < Lb.length; i++) {
		Lb.qlist[i] = arr2[i];
	}
}
//求解A交B
void intersect(Sqlist &La,Sqlist &Lb) {
	int curlength = 0;
	int i = 0;
	int j = 0;
	while (i < La.length && j < Lb.length) {//A表和B表元素进行两两比较如果相等加入新表
		if (La.qlist[i] == Lb.qlist[j]) {
			La.qlist[curlength] = La.qlist[i];
			i++;
			j++;
			curlength++;
		}
		else if(La.qlist[i] > Lb.qlist[j]) {//B表当前元素小于表A当前元素B表下表加一
			j++;
		}
		else {//A表当前元素小于表B当前元素A表下表加一
			i++;
		}
	}
	La.length = curlength;//元素个数改变
}

 八.给定两个非空集合A和B,分别用升序表La与Lb存储,设计算法求解A-B(A中元素减去B中有的元素)

//例11:给定两个非空集合A和B,分别用升序表La与Lb存储,设计算法求解A-B(A中元素减去B中有的元素)
//算法思想跟上一题一样
void except(Sqlist& La, Sqlist& Lb) {
	int curlength = 0;
	int i = 0;
	int j = 0;
	while (i < La.length && j < Lb.length) {
		if (La.qlist[i] == Lb.qlist[j]) {//相等下标都相加
			i++;
			j++;
		}
		else if (La.qlist[i] > Lb.qlist[j]) {//a>b,B下标增加
			j++;
		}
		else {//a<b说明当前A中元素一定是B中没有的
			La.qlist[curlength] = La.qlist[i];
			curlength++;
			i++;
		}
	}
	while (i < La.length) {//将A表剩余元素复制到新表
		La.qlist[curlength] = La.qlist[i];
		curlength++;
		i++;
	}
	La.length = curlength;//元素个数改变
}

九.测试

全部代码:

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#define Max 20

typedef int Elemtype;
//顺序表的动态分配
typedef struct Sqlist {
	Elemtype* qlist;
	int length;
	int maxsize;
};
//定义打印顺序表函数
void print(Sqlist L) {
	for (int i = 0; i < L.length; i++) {//顺序遍历顺序表
		printf("%d ", L.qlist[i]);
	}

	printf("\n顺序表长度为:%d\n", L.length);
	printf("总大小为:%d\n", L.maxsize);
}

//例1:定义创建顺序表并初始化函数
void InitSqlist(Sqlist& L) {//初始化空间为20,长度为15,{ 0,1,2,3,4,4,4,5,6,7,7,8,8,9,9 }
	L.maxsize = Max;
	L.length = 15;
	int arr[15] = { 0,1,2,3,4,4,4,5,6,7,7,8,8,9,9 };
	L.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (L.maxsize));
	for (int i = 0; i < L.length; i++) {
		L.qlist[i] = arr[i];
	}
}
//例6:删除非递减顺序表L中的重复元素
void deletesame(Sqlist &L) {
	int curlenth = 0;
	for (int i = 0; i < L.length; i++) {//每次区元素与新表最后一个元素进行比较如果不相等加入新表
		if (curlenth == 0 || L.qlist[i] != L.qlist[curlenth - 1]) {
			L.qlist[curlenth++] = L.qlist[i];
		}
	}
	L.length = curlenth;
}
//例7:在非递减顺序表中删除[s,t]之间的元素
void deletest2(Sqlist& L, int s, int t) {
	int curlength = 0;
	int i = 0;
	for (; i < L.length; i++) {//从前往后找第一个大于或等于s的元素的位置
		if (L.qlist[i] >= s) {
			break;
		}
	}
	curlength = i;
	i = L.length - 1;
	for (; i >= 0; i--) {//从后往前找第一个小于或等于t的元素的位置
		if (L.qlist[i] <= t) {
			break;
		}
	}
	i= i + 1;//指向下一个元素才是要复制的元素
	for (;  i< L.length; i++) {//复制元素
		L.qlist[curlength++] = L.qlist[i];
	}
	L.length = curlength;
}
//例8:设计算法逆置顺序表L,并将序列L循环左移
//定义逆置函数
void reverse1(Sqlist& L) {
	int low = 0;
	int high = L.length - 1;
	while (low < high) {//设置low和high指针对表中元素进行两两交换
		Elemtype tmp = L.qlist[low];
		L.qlist[low] = L.qlist[high];
		L.qlist[high] = tmp;
		low++;
		high--;
	}
}
void reverse2(Sqlist& L,int low ,int high) {
	while (low < high) {
		Elemtype tmp = L.qlist[low];
		L.qlist[low] = L.qlist[high];
		L.qlist[high] = tmp;
		low++;
		high--;
	}
}
void ROL(Sqlist &L, int r) {
	reverse2(L, 0, L.length - 1);//整体逆置
	reverse2(L, 0, r-1);//前r个元素逆置
	reverse2(L, r, L.length - 1);//后面元素逆置
}
//例9:顺序表A和B的元素个数分别为m,n.A表升序排序,B表降序排序,两表中都不存在相同元素
//(1)将两表合并,两表中元素都储存在C中
//创建La和Lb
void creatLaLb(Sqlist& La, Sqlist& Lb) {
	La.maxsize = 11;
	La.length = 6;
	int arr1[6] = { 0,2,4,7,8,9 };
	La.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (La.maxsize));
	for (int i = 0; i < La.length; i++) {
		La.qlist[i] = arr1[i];
	}
	Lb.maxsize = 11;
	Lb.length = 5;
	int arr2[5] = { 10,6,5,3,1 };
	Lb.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (Lb.maxsize));
	for (int i = 0; i < Lb.length; i++) {
		Lb.qlist[i] = arr2[i];
	}
}
//归并排序思想
void mergesort1(Sqlist& La, Sqlist& Lb, Sqlist& Lc) {
	int length = La.length + Lb.length;
	Lc.qlist = (Elemtype*)malloc(sizeof(Elemtype) * length);
	assert(Lc.qlist);
	Lc.maxsize = length;
	int curlength = 0;
	int i = 0;
	int j = Lb.length-1;
	while (i < La.length && j >=0) {
		if (La.qlist[i] > Lb.qlist[j]) {
			Lc.qlist[curlength] = Lb.qlist[j];
			curlength++;
			j--;
		}
		else {
			Lc.qlist[curlength] = La.qlist[i];
			curlength++;
			i++;
		}
	}
	while (i < La.length) {
		Lc.qlist[curlength++] = Lb.qlist[i];
		i++;
	}
	while (j >=0) {
		Lc.qlist[curlength++] = Lb.qlist[j];
		j--;
	}
	Lc.length = curlength;
}
//(2)表A有m+n个存储空间,将A,B两表合并所有元素都存储到A中
void mergesort2(Sqlist& La, Sqlist& Lb) {
	int curlength = 0;
	int i = La.length-1;//A表后
	int j = 0;//B表头
	while (i >= 0 && j < Lb.length) {//将A表与B表元素进行比较将大的存入A表后
		if (La.qlist[i] > Lb.qlist[j]) {
			La.qlist[La.maxsize - curlength - 1] = La.qlist[i];
			curlength++;
			i--;
		}
		else {
			La.qlist[La.maxsize - curlength - 1] = Lb.qlist[j];
			curlength++;
			j++;
		}
	}
	while (i >= 0) {//将A表剩余元素直接复制到A表中
		La.qlist[La.maxsize - curlength - 1] = La.qlist[i];
		curlength++;
		i--;
	}
	while (j < Lb.length) {//将B表剩余元素直接复制到A表中
		La.qlist[La.maxsize - curlength - 1] = Lb.qlist[j];
		curlength++;
		j++;
	}
	La.length = La.length + Lb.length;
}
//(3)对表A进行简单插入排序
void selectsort(Sqlist& L) {
	int i = 0;
	int j = 0;
	while (i < L.length) {//每次选取一个元素
		Elemtype e = L.qlist[i];
		j = i - 1;
		while (j >= 0 && e < L.qlist[j]) {//寻找插入位置
			L.qlist[j + 1] = L.qlist[j];
			j--;
		}
		L.qlist[j + 1] = e;
		i++;
	}
}
//例10:给定两个非空集合A和B,分别用升序顺序表La,Lb存储,设计算法求解A交B
//创建两个升序La表和Lb表
void creatLaLb2(Sqlist& La, Sqlist& Lb) {
	La.maxsize = 20;
	La.length = 11;
	int arr1[11] = { 1,1,2,2,3,3,4,4,5,5,6 };
	La.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (La.maxsize));
	for (int i = 0; i < La.length; i++) {
		La.qlist[i] = arr1[i];
	}
	Lb.maxsize = 20;
	Lb.length = 11;
	int arr2[11] = { 1,1,2,2,4,4,5,5,6,6,7 };
	Lb.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (Lb.maxsize));
	for (int i = 0; i < Lb.length; i++) {
		Lb.qlist[i] = arr2[i];
	}
}
//求解A交B
void intersect(Sqlist &La,Sqlist &Lb) {
	int curlength = 0;
	int i = 0;
	int j = 0;
	while (i < La.length && j < Lb.length) {//A表和B表元素进行两两比较如果相等加入新表
		if (La.qlist[i] == Lb.qlist[j]) {
			La.qlist[curlength] = La.qlist[i];
			i++;
			j++;
			curlength++;
		}
		else if(La.qlist[i] > Lb.qlist[j]) {//B表当前元素小于表A当前元素B表下表加一
			j++;
		}
		else {//A表当前元素小于表B当前元素A表下表加一
			i++;
		}
	}
	La.length = curlength;//元素个数改变
}
//例11:给定两个非空集合A和B,分别用升序表La与Lb存储,设计算法求解A-B(A中元素减去B中有的元素)
//算法思想跟上一题一样
void except(Sqlist& La, Sqlist& Lb) {
	int curlength = 0;
	int i = 0;
	int j = 0;
	while (i < La.length && j < Lb.length) {
		if (La.qlist[i] == Lb.qlist[j]) {//相等下标都相加
			i++;
			j++;
		}
		else if (La.qlist[i] > Lb.qlist[j]) {//a>b,B下标增加
			j++;
		}
		else {//a<b说明当前A中元素一定是B中没有的
			La.qlist[curlength] = La.qlist[i];
			curlength++;
			i++;
		}
	}
	while (i < La.length) {//将A表剩余元素复制到新表
		La.qlist[curlength] = La.qlist[i];
		curlength++;
		i++;
	}
	La.length = curlength;//元素个数改变
}
int main() {
	printf("+++++++++++++++++++++++++++++++++++++++\n");
	printf("对InitSqlist进行测试!\n");
	Sqlist L;
	InitSqlist(L);
	print(L);//打印顺序表以及信息
	printf("+++++++++++++++++++++++++++++++++++++++\n");
	printf("对deletesame进行测试!\n");
	deletesame(L);
	print(L);
	InitSqlist(L);
	printf("+++++++++++++++++++++++++++++++++++++++\n");
	printf("对deletest2进行测试!\n");
	deletest2(L, 4, 7);
	print(L);
	InitSqlist(L);
	printf("+++++++++++++++++++++++++++++++++++++++\n");
	printf("对reverse2进行测试!\n");
	reverse1(L);
	print(L);
	InitSqlist(L);
	reverse2(L, 0, L.length - 1);
	print(L);
	InitSqlist(L);
	printf("+++++++++++++++++++++++++++++++++++++++\n");
	printf("对ROL进行测试!\n");
	print(L);
	ROL(L,3);
	print(L);
	InitSqlist(L);
	printf("+++++++++++++++++++++++++++++++++++++++\n");
	printf("对例8进行测试!\n");
	Sqlist La,Lb,Lc;
	printf("创建La和Lb顺序表\n");
	creatLaLb(La, Lb);
	print(La);
	print(Lb);
	printf("归并La和Lb顺序表\n");
	mergesort1(La, Lb, Lc);
	print(Lc);
	printf("归并La和Lb顺序表用原空间\n");
	mergesort2(La, Lb);
	print(La);
	print(Lb);
	creatLaLb(La, Lb);//初始化一下
	Sqlist LA;
	LA.maxsize = Max;
	LA.length = 12;
	int arr[12] = { 3,6,2,1,7,8,4,5,9,10,12,11 };
	LA.qlist = (Elemtype*)malloc(sizeof(Elemtype) * (LA.maxsize));
	for (int i = 0; i < L.length; i++) {
		LA.qlist[i] = arr[i];
	}
	print(LA);
	printf("对表A进行简单选择插入排序!\n");
	selectsort(LA);
	print(LA);
	printf("+++++++++++++++++++++++++++++++++++++++\n");
	printf("对例10进行测试!\n");
	creatLaLb2(La, Lb);
	print(La);
	print(Lb);
	intersect(La, Lb);
	print(La);
	printf("+++++++++++++++++++++++++++++++++++++++\n");
	printf("对例11进行测试!\n");
	creatLaLb2(La, Lb);
	print(La);
	print(Lb);
	except(La, Lb);
	print(La);
	return 0;

}

 输出结果:

总结

写了几个经典的顺序表的题目,有些函数作用是创建表的,可以省略,主要是解决问题的思路和方法,输出结果比较常所以我分成了两张图片,大家自行比对,或者直接复制代码上机运行,有问题的地方可以私信我.

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

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

相关文章

四、Qt 的第一个demo

四、Qt 的第一个demo

在上一篇章节里《三、Qt Creator 使用》&#xff0c;我们介绍了如何使用Qt Creator创建一个简单的带窗体的demo&#xff0c;在这一章节里&#xff0c;我们详细讲解一下这个demo的文件组成&#xff0c;及主函数&#xff0c;并在UI上加一些控件&#xff0c;实现一些简单的功能。 …
阅读更多...
SDRAM小项目——写模块

SDRAM小项目——写模块

写模块跟着视频看了一个多星期&#xff0c;一开始始终有点弄不清楚&#xff0c;现在记录一下理解的过程。 阅读文档信息&#xff1a; 首先阅读文档信息&#xff0c;了解SDRAM写过程的状态转换和时序图 SDRAM整体状态流程如图所示&#xff1a; 在SDRAM整体系统中&#xff0c…
阅读更多...
谈⼀谈你对TCPIP四层模型,OSI七层模型的理解

谈⼀谈你对TCPIP四层模型,OSI七层模型的理解

TCP/IP四层模型 对比 OSI七层模型 OSI七层模型 为了增强通⽤性和兼容性&#xff0c;计算机⽹络都被设计成层次机构&#xff0c;每⼀层都遵守⼀定的规则。因此有了OSI这样⼀个抽象的⽹络通信参考模型&#xff0c;按照这个标准使计算机⽹络系统可以互相连接 物理层 通过⽹线、光…
阅读更多...
南京观海微电子----时序分析基本概念（一）——建立时间

南京观海微电子----时序分析基本概念（一）——建立时间

1. 概念的理解 以上升沿锁存为例&#xff0c;建立时间&#xff08;Tsu&#xff09;是指在时钟翻转之前输入的数据D必须保持稳定的时间。如下图所示&#xff0c;一个数据要在上升沿被锁存&#xff0c;那么这个数据就要在时钟上升沿的建立时间内保持稳定。 建立时间是对触发器而…
阅读更多...
Akira勒索软件团伙及其策略的全面解析

Akira勒索软件团伙及其策略的全面解析

Sophos MDR威胁情报团队曾于2023年5月发表过一篇博文&#xff0c;称Akira勒索软件“将1988年的时光带回”。起因是Akira会将受害者网站篡改为具有复古美学的页面&#xff0c;让人想起20世纪80年代的绿色屏幕控制台。而且&#xff0c;Akira的名字也可能取自1988年流行的同名动画…
阅读更多...
HCIA的访问控制列表ACL

HCIA的访问控制列表ACL

ACL&#xff1a;访问控制列表 -----控制列表&#xff08;策略列表&#xff09; 功能&#xff1a; 1&#xff1a;定义感兴趣的路由&#xff08;控制层面&#xff09; 可以定义感兴趣的路由&#xff0c;可以把感兴趣的路由抓取出来&#xff0c;给它做过滤&#xff0c;也可以改变…
阅读更多...
polar CTF CB链

polar CTF CB链

一、题目 二、解答 1、通过jar包&#xff0c;可以看到/user路由下有反序列化操作 看到存在commons-beanutils依赖且版本为1.9.2&#xff0c;可利用CB链Getshell。 使用ysoserial项目中的CommonsBeanutils1链写一个POC&#xff0c;注意确保ysoserial项目中的pom.xml中的comm…
阅读更多...
寡年是否适合结婚？寡妇年结婚有什么禁忌吗？让程序来告诉你有多少人是寡妇年结婚的。

寡年是否适合结婚？寡妇年结婚有什么禁忌吗？让程序来告诉你有多少人是寡妇年结婚的。

什么是寡年&#xff1f; 百度百科 原文&#xff1a;寡年-百度百科 指整年没有“立春”的日子就是“盲年”&#xff0c;俗称寡年。又名滑头年 社会上流传的“寡妇年”&#xff0c;是指整个农历年都没有立春的年份。以农历2005年的鸡年为例&#xff0c;立春在公历2月4日&…
阅读更多...
Rust-内存安全

Rust-内存安全

堆和栈 一个进程在执行的时候&#xff0c;它所占用的内存的虚拟地址空间一般被分割成好几个区域&#xff0c;我们称为“段”(Segment)。常见的几个段如下。 代码段。编译后的机器码存在的区域。一般这个段是只读的。bss段。存放未初始化的全局变量和静态变量的区域。数据段。…
阅读更多...
java： 5-6 break

java： 5-6 break

文章目录 1. break1.1 介绍1.2 语法和流程图1.3 入门练习1.4 细节说明1.5 练习 【老韩视频p137-】 1. break 看个需求&#xff1a;随机生成 1-100 的一个数&#xff0c;直到生成了 97 这个数&#xff0c;看看你一共用了几次? 【思路分析:循环&#xff0c;但是循环的次数不知道…
阅读更多...
NLP论文阅读记录 - 2022 W0S | 基于Longformer和Transformer的提取摘要层次表示模型

NLP论文阅读记录 - 2022 W0S | 基于Longformer和Transformer的提取摘要层次表示模型

文章目录 前言0、论文摘要一、Introduction1.1目标问题1.2相关的尝试1.3本文贡献 二.相关工作三.本文方法四 实验效果4.1数据集4.2 对比模型4.3实施细节4.4评估指标4.5 实验结果4.6 细粒度分析 五 总结思考 前言 A Hierarchical Representation Model Based on Longformer and …
阅读更多...
【模型评估 04】A/B测试的陷阱

【模型评估 04】A/B测试的陷阱

互联网公司中&#xff0c;A/B测试是验证新模块、新功能、新产品是否有效&#xff1b;新算法、新模型的效果是否有提升&#xff1b;新设计是否受到用户欢迎&#xff1b;新更改是否影响用户体验的主要测试方法。在机器学习领域中&#xff0c;A/B测试是验证模型最终效果的主要手段…
阅读更多...
知乎x-zse-96算法分析

知乎x-zse-96算法分析

声明 本文以教学为基准、本文提供的可操作性不得用于任何商业用途和违法违规场景。 本人对任何原因在使用本人中提供的代码和策略时可能对用户自己或他人造成的任何形式的损失和伤害不承担责任。 如有侵权，请联系我进行删除。 这里只是我分析过程，以及一些重要点的记录，没有…
阅读更多...
yolov5的完整部署（适合新人和懒人，一键安装）

yolov5的完整部署（适合新人和懒人，一键安装）

第一步&#xff1a;安装Anaconda 下载并安装后&#xff0c;配置一下镜像 在这里面&#xff0c;看情况输入镜像源&#xff0c;这里我建议大家搞阿里云镜像源。 # 添加清华源 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ conda conf…
阅读更多...
零知识证明的最新发展和应用

零知识证明的最新发展和应用

PrimiHub一款由密码学专家团队打造的开源隐私计算平台&#xff0c;专注于分享数据安全、密码学、联邦学习、同态加密等隐私计算领域的技术和内容。 当企业收集大量客户数据去审查、改进产品和服务以及将数据资产货币化时&#xff0c;他们容易受到网络攻击威胁&#xff0c;造成数…
阅读更多...
从Demo理解Thrift Thrift和Dubbo的区别

从Demo理解Thrift Thrift和Dubbo的区别

文章目录 安装demo尝试Thrift协议栈Thrift 与 Dubbo 的区别 字节里的RPC框架都是用的Thrift&#xff0c;我猜这主要原因有2: Thrift是Facebook开源的项目&#xff0c;平台中立Thrift支持跨语言调用&#xff0c;这非常适合字节Java、Go语言都存在的环境&#xff0c;语言中立 但…
阅读更多...
手把手Docker部署Gitblit服务器

手把手Docker部署Gitblit服务器

1拉取镜像 docker pull jacekkow/gitblit:v1.9.1 2.启动 docker run -d --name gitblit --restart always -p 10006:8080 -p 18443:8443 -p 19418:9418 -p 29418:29418 -v /data/gitblit/data:/opt/gitblit-data jacekkow/gitblit:v1.9.1 3.查看 默认账户/密码:admin/adm…
阅读更多...
运算放大器相关知识总结（1）

运算放大器相关知识总结（1）

1、 前言 最近做了一个小项目&#xff0c;这个项目是研发一款阻抗测量仪。这个阻抗测量仪可以测量人体在不同频率下的生物电阻抗&#xff0c;该设备的核心是模拟电路&#xff0c;技术难点是减小模拟电路噪声。该项目前前忙了2个多月&#xff0c;借着研发这个项目的机会把自己掌…
阅读更多...
Jenkins-用户管理

Jenkins-用户管理

用户管理 1 安装插件 2 选择安全策略为刚刚安装的插件 3 这个是安装插件以后会有的选项 4 增加一个角色 5 根据需要赋值角色的权限&#xff0c;并分配给用户
阅读更多...
Protecting Intellectual Property of Deep NeuralNetworks with Watermarking

Protecting Intellectual Property of Deep NeuralNetworks with Watermarking

保护深度神经网络的知识产权与数字水印技术 ABSTRACT 深度学习是当今人工智能服务的关键组成部分&#xff0c;在视觉分析、语音识别、自然语言处理等多个任务方面表现出色&#xff0c;为人类提供了接近人类水平的能力。构建一个生产级别的深度学习模型是一项非常复杂的任务&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023