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

目录

 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;
}

测试结果为

 

 

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Linux socket编程(9):IO复用之poll和epoll详解

Linux socket编程(9):IO复用之poll和epoll详解

在之前的文章中&#xff0c;我们学习了IO复用模型之select原理及例子&#xff0c;但是select有监听描述符个数的限制&#xff0c;而且select的效率并不高&#xff0c;所以这篇文章就来学习效率更高的poll和Linux特有的epoll方法。 文章目录 1 select/poll/epoll对比2 poll2.1 p…
阅读更多...
【开源项目】Windows串口通信组件 -- Com.Gitusme.IO.Ports.SerialPort

【开源项目】Windows串口通信组件 -- Com.Gitusme.IO.Ports.SerialPort

目录 1、项目介绍 2、组件集成 1&#xff09;下载地址&#xff1a; 2&#xff09;添加项目依赖 3、使用方法 4、GitHub项目地址 1、项目介绍 Com.Gitusme.IO.Ports.SerialPort 是一款 Windows 串口通信组件&#xff0c;基于.Net Core 3.1 开发&#xff0c;支持 Console、Wi…
阅读更多...
PostgreSQL有意思的现象：支持不带列的表

PostgreSQL有意思的现象：支持不带列的表

1、前言 以前从没有试过建一张表&#xff0c;不带任何列。在PG中却支持这种语法。这是个什么鬼? 最近&#xff0c;把PG源码扒了下&#xff0c;简单浏览了下最近的一些merge。其中有一个fix&#xff1a; eeb0ebad79 ("Fix the initial sync tables with no columns.&qu…
阅读更多...
CRM简单小结

CRM简单小结

思想 对于三层架构&#xff0c;一个模块对应一个controller&#xff0c;controller实际就是Servlet&#xff1b;一张表对应一个domain类对应一个dao接口对应一个mapper文件&#xff1b;service层没有严格规定&#xff0c;如果两张表内容相近&#xff0c;用一个service接口也可以…
阅读更多...
【C++练级之路】【Lv.2】类和对象（上）（类的定义，访问限定符，类的作用域，类的实例化，类的对象大小，this指针）

【C++练级之路】【Lv.2】类和对象（上）（类的定义，访问限定符，类的作用域，类的实例化，类的对象大小，this指针）

目录 一、面向过程和面向对象初步认识二、类的引入三、类的定义四、类的访问限定符及封装4.1 访问限定符4.2 封装 五、类的作用域六、类的实例化七、类的对象大小的计算7.1 类对象的存储方式猜测7.2 如何计算类对象的大小 八、类成员函数的this指针8.1 this指针的引出8.2 this指…
阅读更多...
排序算法介绍（二）冒泡排序

排序算法介绍（二）冒泡排序

0. 简介 冒泡排序&#xff08;Bubble Sort&#xff09;是一种简单的排序算法。它重复地遍历要排序的数列&#xff0c;一次比较两个元素&#xff0c;如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换&#xff0c;也就是说该数列已经排…
阅读更多...
CentOS7搭建部署NTP服务器

CentOS7搭建部署NTP服务器

服务端配置&#xff1a; yum install ntp ntpdate -y #下载安装包 修改配置文件&#xff0c;同步阿里的NTP服务器 vim /etc/ntp.conf systemctl start ntpd #启动该服务 ntpq -p #查看是否同步了阿里的NTP 服务端同步成功后&#xff0c;可以去新增…
阅读更多...
移除元素、合并两个有序数组（leetcode）

移除元素、合并两个有序数组（leetcode）

一、移除元素 思路三&#xff1a; while(src<numsSize) 使用一个 while 循环来遍历数组。循环的条件是 src 必须小于 numsSize&#xff0c;以确保不会越界。 if(nums[src]!val) 如果当前 src 指向的元素不等于给定的值 val&#xff0c;则执行以下操作&#xff1a; nums[ds…
阅读更多...
国际语音通知系统有哪些优点？国际语音通知系统有哪些应用场景?

国际语音通知系统有哪些优点？国际语音通知系统有哪些应用场景?

国际语音通知是一种全球性的通信工具&#xff0c;它通过语音方式向用户发送各种重要信息和提示。无论是快递到货的取件提醒、机场航班的延误通知&#xff0c;还是银行账户的余额提醒&#xff0c;国际语音通知都能准确、迅速地将信息传达给用户。 三、国际语音通知系统有哪些优…
阅读更多...
Jupyter NoteBook未授权访问漏洞

Jupyter NoteBook未授权访问漏洞

任务一&#xff1a; 复现未授权访问的漏洞 任务二&#xff1a; 利用Jupter Notebook控制台执行系统命令&#xff0c;读取/etc/passwd内容 1.搭建环境 2.new下面直接进入终端&#xff0c;而且也不需要登录&#xff0c;我就直接进入了管理界面 3.直接把指令输入进入&#xf…
阅读更多...
【Unity动画】为一个动画片段添加事件Events

【Unity动画】为一个动画片段添加事件Events

动画不管播放到那一帧&#xff0c;我们都可以在这里“埋伏”一个事件&#xff08;调用一个函数并且给函数传递一个参数&#xff0c;参数在外部设置&#xff0c;甚至传递一个物体&#xff09;&#xff01; 嗨&#xff0c;亲爱的Unity小伙伴们&#xff01;你是否曾想过为你的动画…
阅读更多...
Java 数组另类用法（字符来当数组下标使用）

Java 数组另类用法（字符来当数组下标使用）

一、原因 看力扣的时候发现有位大佬使用字符来当数组下标使用。 class Solution {public int lengthOfLongestSubstring(String s) {int result 0;int[] hash new int[130];int i 0;for(int j 0; j < s.length(); j) {while(hash[s.charAt(j)] > 0) {hash[s.charAt…
阅读更多...
基于SSM框架开发的酒店后台管理系统

基于SSM框架开发的酒店后台管理系统

基于SSM框架开发的酒店后台管理系统 文章目录 基于SSM框架开发的酒店后台管理系统 一.引言二.系统设计三.技术架构四.功能实现五.界面展示六.源码获取 一.引言 酒店管理系统是一个集客房预订、前台管理、客户服务、财务管理等功能于一体的综合性软件系统。它能够帮助酒店高效地…
阅读更多...
C++面试宝典第1题：爬楼梯

C++面试宝典第1题：爬楼梯

题目 小乐爬楼梯&#xff0c;一次只能上1级或者2级台阶。楼梯一共有n级台阶&#xff0c;请问总共有多少种方法可以爬上楼&#xff1f; 解析 这道题虽然是一道编程题&#xff0c;但实际上更是一道数学题&#xff0c;着重考察应聘者的逻辑思维能力和分析解决问题的能力。 当楼梯只…
阅读更多...
检测下我的饺子皮擀的怎么样（圆度）

检测下我的饺子皮擀的怎么样（圆度）

&#x1f604;&#x1f60a;&#x1f606;&#x1f603;&#x1f604;&#x1f60a;&#x1f606;&#x1f603; 各位老铁周末愉快。 快乐的时间做充实的事&#xff0c;好久没有吃饺子了&#xff0c;俗话说好吃不过饺子。 我个人觉得会包饺子不算本事&#xff0c;会擀饺子皮…
阅读更多...
一次电气——电抗器（一）

一次电气——电抗器（一）

我之前的工作是在国外建联合循环电厂&#xff0c;现在的工作是研发一次电力设备。虽然仍是在电力行业发展&#xff0c;但这两份不同岗位不同职能的工作究其感受而言有很大的不同。相较于第一份工作&#xff0c;第二份工作带给我带来的更多的是一种由广及微&#xff0c;由浅入深…
阅读更多...
Linux系统-----进程通讯

Linux系统-----进程通讯

前言 本期我们来学习进程间的通讯&#xff0c;不同进程之间是可以去通过信号来去实现通讯交流的&#xff0c;下面我们就一起来看看多进程之间的通讯方式。 一、信号机制 1、信号的基本概念 每个信号都对应一个正整数常量(称为signal number,即信号编号。定义在系统头文件<…
阅读更多...
Android开发，JNI开发项目创建

Android开发，JNI开发项目创建

文章目录 Android开发&#xff0c;JNI开发项目创建1.jni是什么 Android开发&#xff0c;JNI开发项目创建 创建工程 1.jni是什么 使得java可以访问底层c语言&#xff0c;java本地化接口&#xff0c;是桥梁。 运行下我们的项目 出现这个就是我们的JNI开发环境已经配置好了 是…
阅读更多...
算法通关村第七关—迭代实现二叉树的遍历(黄金)

算法通关村第七关—迭代实现二叉树的遍历(黄金)

迭代实现二叉树的遍历 迭代法实现前序遍历 前序遍历是中左右&#xff0c;如果还有左子树就一直向下找。完了之后再返回从最底层逐步向上向右找。不难写出如下代码&#xff1a;&#xff08;注意代码中&#xff0c;空节点不入栈&#xff09; public List<Integer>preorde…
阅读更多...
组合总和II（回溯、去重）

组合总和II（回溯、去重）

40. 组合总和 II - 力扣&#xff08;LeetCode&#xff09; 题目描述 给定一个候选人编号的集合 candidates 和一个目标数 target &#xff0c;找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用 一次 。 注意&#xff1a…
阅读更多...
最新文章

Copyright @ 2022~2023