严蔚敏数据结构p17（2.19）——p18(2.24) (c语言代码实现)

news2025/8/15 10:37:48

2.19已知线性表中的元素以值递增有序排列,并以单链表作存储结构。试写一高效的算法,
删除表中所有值大于 mink 且小于 maxk 的元素(若表中存在这样的元素）同时释放被删结点空间,
并分析你的算法的时间复杂度(注意:mink 和 maxk 是给定的个参变量,它们的值可以和表中的元素相同,也可以不同)。

本题代码如下

void deletemidst(linklist* L, int mink, int maxk)
{
    lnode* p = (*L)->next, * pre = *L; // 定义指针p和pre分别指向链表头结点的下一个结点和链表头结点
    lnode* q; // 定义指针q用于释放临时结点
    while (p) // 遍历链表
    {
        if (p->data > mink && p->data < maxk) // 如果当前结点的值在指定范围内
        {
            q = p; // 将当前结点赋值给临时结点q
            p = p->next; // 将指针p指向下一个结点
            pre->next = p; // 将指针pre的next指针指向下一个结点
            free(q); // 释放临时结点q所占用的内存空间
        }
        else // 如果当前结点的值不在指定范围内
        {
            p = p->next; // 将指针p指向下一个结点
            pre = pre->next; // 将指针pre指向下一个结点
        }
    }
}

完整测试代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
    int data; // 数据域，存储整数值
    struct lnode* next; // 指针域，指向下一个节点
}lnode, * linklist; // 定义链表结构体和指针类型
int a[8] = { 1,2,3,4,5,6,7,8 }; // 初始化数组a
int n = 8; // 数组a的长度
// 构建链表函数
void buildlinklist(linklist* L)
{
    *L = (lnode*)malloc(sizeof(lnode)); // 分配内存空间给链表头结点
    (*L)->next = NULL; // 初始化链表头结点的next指针为NULL
    lnode* s, * r = *L; // 定义临时结点s和当前结点r
    int i = 0;
    for (i = 0; i < n; i++) // 遍历数组a
    {
        s = (lnode*)malloc(sizeof(lnode)); // 分配内存空间给临时结点s
        s->data = a[i]; // 将数组a中的元素赋值给临时结点s的data域
        s->next = r->next; // 将当前结点的next指针指向临时结点的next指针所指向的结点
        r->next = s; // 将当前结点的next指针指向临时结点s
        r = s; // 更新当前结点r为临时结点s
    }
    r->next = NULL; // 将最后一个结点的next指针设为NULL
}
// 删除指定范围内的值函数
void deletemidst(linklist* L, int mink, int maxk)
{
    lnode* p = (*L)->next, * pre = *L; // 定义指针p和pre分别指向链表头结点的下一个结点和链表头结点
    lnode* q; // 定义指针q用于释放临时结点
    while (p) // 遍历链表
    {
        if (p->data > mink && p->data < maxk) // 如果当前结点的值在指定范围内
        {
            q = p; // 将当前结点赋值给临时结点q
            p = p->next; // 将指针p指向下一个结点
            pre->next = p; // 将指针pre的next指针指向下一个结点
            free(q); // 释放临时结点q所占用的内存空间
        }
        else // 如果当前结点的值不在指定范围内
        {
            p = p->next; // 将指针p指向下一个结点
            pre = pre->next; // 将指针pre指向下一个结点
        }
    }
}
// 打印链表函数
void print(linklist* L)
{
    lnode* k = (*L)->next; // 定义指针k指向链表头结点的下一个结点
    while (k) // 遍历链表
    {
        printf("%d ", k->data); // 输出当前结点的值
        k = k->next; // 将指针k指向下一个结点
    }
}

int main()
{
    linklist L; // 定义链表L
    buildlinklist(&L); // 调用构建链表函数
    printf("原始单链表为："); // 输出提示信息
    print(&L); // 调用打印链表函数
    printf("删除mink与maxk中间的值后的单链表为："); // 输出提示信息
    deletemidst(&L, 2, 6); // 调用删除指定范围内的值函数
    print(&L); // 调用打印链表函数
    return 0; // 返回0表示程序正常结束
}

测试结果为

 

2.20 同 2.19 题条件,试写一高效的算法，删除表中所有值相同的多余元素(得操作后的线性表中所有元素的值均不相同),同时释放被删结点空间，并分析你的算法的时间复杂度。

本题代码如下

void deleterepeat(linklist* L)
{
	lnode* p = (*L)->next, * pre = *L;//p为工作指针，pre为它的前驱指针防止断链
	lnode* q;
	while (p->next!=NULL)
	{
		if (p->next->data == pre->next->data)//如果p的后继的值域等与它本身则执行删除操作
		{
			q = p;
			p = p->next;
			pre->next = p;
			free(q);
		}
		else//否则继续向后遍历
		{
			p = p->next;
			pre = pre->next;
		}
	}
}void deleterepeat(linklist* L)
{
	lnode* p = (*L)->next, * pre = *L;//p为工作指针，pre为它的前驱指针防止断链
	lnode* q;
	while (p->next!=NULL)
	{
		if (p->next->data == pre->next->data)//如果p的后继的值域等与它本身则执行删除操作
		{
			q = p;
			p = p->next;
			pre->next = p;
			free(q);
		}
		else//否则继续向后遍历
		{
			p = p->next;
			pre = pre->next;
		}
	}
}

完整测试代码

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode,*linklist;
int a[8] = { 1,2,2,3,3,4,5,6 };
int n = 8;
void buildlinklist(linklist* L)
{
	*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 = a[i];
		s->next = r->next;
		r->next = s;
		r = s;
	}
	r->next = NULL;
}
void deleterepeat(linklist* L)
{
	lnode* p = (*L)->next, * pre = *L;//p为工作指针，pre为它的前驱指针防止断链
	lnode* q;
	while (p->next!=NULL)
	{
		if (p->next->data == pre->next->data)//如果p的后继的值域等与它本身则执行删除操作
		{
			q = p;
			p = p->next;
			pre->next = p;
			free(q);
		}
		else//否则继续向后遍历
		{
			p = p->next;
			pre = pre->next;
		}
	}
}
void print(linklist* L)
{
	lnode* k = (*L)->next;
	while (k)
	{
		printf("%d ", k->data);
		k = k->next;
	}
}
int main()
{
	linklist L;
	buildlinklist(&L);
	printf("原始单链表为："); 
    print(&L); // 调用打印链表函数
    printf("\n删除重复值后的单链表为：");
    deleterepeat(&L); // 调用删除重复值的函数
    print(&L); // 调用打印链表函数
    return 0; // 返回0表示程序正常结束
}

测试结果为

 

2.21 试写一算法,实现顺序表的就地逆置，即利用原表的存储空间将线性表(a1,a2,...,an)逆置为(an,...,a2,a1)。可以看下面这个（说的不好请见谅）👇

c语言代码实现数据结构课后代码题顺序表p18 2_哔哩哔哩_bilibili

本题代码如下

void nizhi(struct sqlist *s)
{
	int i = 0; // 定义一个整型变量i，用于遍历顺序表
	int j = s->length; // 定义一个整型变量j，用于存储顺序表的长度
	int temp = 0; // 定义一个整型变量temp，用于临时存储元素
	for (i = 0; i < s->length / 2; i++) // 遍历顺序表的前半部分
	{
		temp = s->a[i]; // 将当前元素存储到temp中
		s->a[i] = s->a[s->length - 1 - i]; // 将后半部分的元素赋值给前半部分
		s->a[s->length - 1 - i] = temp; // 将temp中的元素赋值给后半部分
	}
}

完整测试代码如下

#include<stdio.h>
#define Max 10
struct sqlist
{
	int a[Max];
	int length;
};
void nizhi(struct sqlist *s)
{
	int i = 0; // 定义一个整型变量i，用于遍历顺序表
	int j = s->length; // 定义一个整型变量j，用于存储顺序表的长度
	int temp = 0; // 定义一个整型变量temp，用于临时存储元素
	for (i = 0; i < s->length / 2; i++) // 遍历顺序表的前半部分
	{
		temp = s->a[i]; // 将当前元素存储到temp中
		s->a[i] = s->a[s->length - 1 - i]; // 将后半部分的元素赋值给前半部分
		s->a[s->length - 1 - i] = temp; // 将temp中的元素赋值给后半部分
	}
}
int main()
{
	struct sqlist s; // 定义两个顺序表变量s
	int i = 0; // 定义一个整型变量，用于遍历顺序表s
	s.length = 5; // 设置顺序表s的长度为5
	for (i = 0; i < s.length; i++) // 遍历交集结果
		scanf("%d", &s.a[i]);
	printf("原顺序表为：");
	for (i = 0; i < s.length; i++) // 遍历交集结果
		printf("%d ", s.a[i]); // 输出交集结果中的每个元素
	nizhi(&s);
	printf("\n逆置后的顺序表为：");
	for (i = 0; i < s.length; i++) // 遍历交集结果
		printf("%d ", s.a[i]); // 输出交集结果中的每个元素
	return 0; // 程序正常结束，返回0
}

测试结果为

2.22试写一算法，对单链表实现就地逆置（可以看下面的视频讲解）👇

c语言代码实现数据结构课后代码题顺序表p18 2_哔哩哔哩_bilibili

 本题代码如下

void nizhi(linklist* L)//单链表就地逆置
{
	lnode* p = (*L)->next;
	lnode* r = p;
	(*L)->next = NULL;
	while (p != NULL)
	{
		p = p->next;
		r->next = (*L)->next;
		(*L)->next = r;
		r = p;
	}
}

完整测试代码如下

#include<stdio.h>
#define Max 50
struct sqlist
{
	int a[Max];
	int length;
};
void nizhi(struct sqlist* s)
{
	int temp = 0;
	for (int i = 0; i < s->length / 2; i++)
	{
		temp = s->a[i];
		s->a[i] = s->a[s->length - i - 1];
		s->a[s->length - 1 - i] = temp;
	}
}
int main()
{
	struct sqlist s;
	int j = 0;
	s.length = 5;
	for (j = 0; j < s.length; j++)
		scanf("%d", &s.a[j]);
	printf("原先数组为：");
	for (j = 0; j < s.length; j++)
		printf("%d", s.a[j]);
	nizhi(&s);
	printf("\n逆置后的数组为：");
	for (j = 0; j < s.length; j++)
		printf("%d", s.a[j]);
	return 0;
}

测试结果为 

 

 2.23

本题代码如下

linklist Union(linklist* A, linklist* B)
{
	lnode *C = (lnode*)malloc(sizeof(lnode));
	C->next = NULL;
	lnode* ra = (*A)->next, * rb = (*B)->next;
	lnode* rc = C;
	while (ra && rb)
	{
		if (ra->data<rb->data)//若A中当前结点小于B中当前结点值
		{
			rc->next = ra;
			rc = ra;
			ra = ra->next;
		}
		else if (ra->data>rb->data)//若A中当前结点大于B中当前结点值
		{
			rc->next = rb;
			rc = rb;
			rb = rb->next;
		}
		else
		{
			rc->next = ra;
			rc = ra;
			ra = ra->next;
			rb= rb->next;
		}
	}
	while (ra)//B遍历完,A没有遍历完
	{
		rc->next= ra;
		rc = ra;
		ra = ra->next;
	}
	while (rb)//A遍历完，B没有遍历完
	{
		rc->next = rb;
		rc = rb;
		rb= rb->next;
	}
	rc->next = NULL; //结果表的表尾结点置空
	return C;
}

完整测试代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode, * linklist;
int na = 5;
int nb = 3;
int a[5] = { 1,3,5,7,9};
int b[3] = { 2,4,6 };
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 *C = (lnode*)malloc(sizeof(lnode));
	C->next = NULL;
	lnode* ra = (*A)->next, * rb = (*B)->next;
	lnode* rc = C;
	while (ra && rb)
	{
		if (ra->data<rb->data)//若A中当前结点小于B中当前结点值
		{
			rc->next = ra;
			rc = ra;
			ra = ra->next;
		}
		else if (ra->data>rb->data)//若A中当前结点大于B中当前结点值
		{
			rc->next = rb;
			rc = rb;
			rb = rb->next;
		}
		else
		{
			rc->next = ra;
			rc = ra;
			ra = ra->next;
			rb= rb->next;
		}
	}
	while (ra)//B遍历完,A没有遍历完
	{
		rc->next= ra;
		rc = ra;
		ra = ra->next;
	}
	while (rb)//A遍历完，B没有遍历完
	{
		rc->next = rb;
		rc = rb;
		rb= rb->next;
	}
	rc->next = NULL; //结果表的表尾结点置空
	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, 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.24假设有两个按元素值递增有序排列的线性表A和B均以单链表作存储结构,请编写算法将A表和B表归并成一个按元素值递减有序(即非递增有序,允许表中含有值相同的元素)排列的线性表 C,并要求利用原表(即A表和B 表)的结点空间构造C表。

本题代码如下

linklist Union(linklist* A, linklist* B)
{
	lnode* C = (lnode*)malloc(sizeof(lnode));
	C->next = NULL;
	lnode* ra = (*A)->next, * rb = (*B)->next;
	lnode* rapre = *A, * rbpre = *B;//rapre为ra的前驱指针，rbpre为rb的前去指针 
	lnode* rc = C;
	while (ra && rb)
	{
		if (ra->data < rb->data)//若A中当前结点小于B中当前结点值
		{
			rapre = ra->next;
			ra->next=rc->next ;
			rc->next= ra;
			ra =rapre;
		}
		else if (ra->data > rb->data)//若A中当前结点大于B中当前结点值
		{
			rbpre = rb->next;
			rb->next = rc->next;
			rc->next = rb;
			rb = rbpre;
		}
		else
		{
			rapre = ra->next;
			ra->next = rc->next;
			rc->next = ra;
			ra = rapre;
			rb = rb->next;
		}
	}
	while (ra)//B遍历完,A没有遍历完
	{
		rapre = ra->next;
		ra->next = rc->next;
		rc->next = ra;
		ra = rapre;
	}
	while (rb)//A遍历完，B没有遍历完
	{
		rbpre = rb->next;
		rb->next = rc->next;
		rc->next = rb;
		rb = rbpre;
	}
	return C;
}

完整测试代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode
{
	int data;
	struct lnode* next;
}lnode, * linklist;
int na = 5;
int nb = 8;
int a[5] = { 1,3,5,7,9 };
int b[8] = { 2,4,6,8,10,12,14,16 };
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* C = (lnode*)malloc(sizeof(lnode));
	C->next = NULL;
	lnode* ra = (*A)->next, * rb = (*B)->next;
	lnode* rapre = *A, * rbpre = *B;//rapre为ra的前驱指针，rbpre为rb的前去指针 
	lnode* rc = C;
	while (ra && rb)
	{
		if (ra->data < rb->data)//若A中当前结点小于B中当前结点值
		{
			rapre = ra->next;
			ra->next=rc->next ;
			rc->next= ra;
			ra =rapre;
		}
		else if (ra->data > rb->data)//若A中当前结点大于B中当前结点值
		{
			rbpre = rb->next;
			rb->next = rc->next;
			rc->next = rb;
			rb = rbpre;
		}
		else
		{
			rapre = ra->next;
			ra->next = rc->next;
			rc->next = ra;
			ra = rapre;
			rb = rb->next;
		}
	}
	while (ra)//B遍历完,A没有遍历完
	{
		rapre = ra->next;
		ra->next = rc->next;
		rc->next = ra;
		ra = rapre;
	}
	while (rb)//A遍历完，B没有遍历完
	{
		rbpre = rb->next;
		rb->next = rc->next;
		rc->next = rb;
		rb = rbpre;
	}
	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, na);
	buildlinklist(&B, b, nb);
	printf("A链表为：");
	print(&A);
	printf("\nB链表为：");
	print(&B);
	linklist C = Union(&A, &B);
	printf("\n合并后的链表为：");
	print(&C);
	return 0;
}

测试结果如下

 

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

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

相关文章

QNX时钟调研

QNX时钟调研

SYSPAGE_ENTRY()的使用&#xff0c;SYSPAGE_ENTRY 测试QNX下printf(“poo\n”);的耗时 #include <sys/neutrino.h> #include <inttypes.h> #include <stdio.h> #include <stdlib.h> #include <sys/syspage.h>int main( void ) {uint64_t cps, …
阅读更多...
P7 链表 链表头前方插入新节点

P7 链表 链表头前方插入新节点

目录 前言 01 链表头插入数据 示例代码 02 指定节点前方插入新节点 测试代码 前言 &#x1f3ac; 个人主页&#xff1a;ChenPi &#x1f43b;推荐专栏1: 《C》✨✨✨ &#x1f525; 推荐专栏2: 《 Linux C应用编程&#xff08;概念类&#xff09;_ChenPi的博客-CSDN博客》✨…
阅读更多...
Linux系统配置深度学习环境之cudnn安装

Linux系统配置深度学习环境之cudnn安装

前言 一个针对深度学习应用优化的 GPU 加速库。它提供了高性能、高可靠性的加速算法&#xff0c;旨在加速深度神经网络模型的训练和推理过程。 cuDNN 提供了一系列优化的基本算法和函数&#xff0c;包括卷积、池化、规范化、激活函数等&#xff0c;以及针对深度学习任务的高级功…
阅读更多...
【MySQL的DQL查询语句】

【MySQL的DQL查询语句】

MySQL的DQL查询语句-----在Navicat下 将学生表导入Navicat中查询语句查询一整张表查询年龄大于22年龄大于22的女生查找文科的学生查找六班的学生计算学生的总分 &#xff08;group by&#xff09;合并两表 &#xff08;join on xxxx&#xff09;合并两张表 并求总分先合并在聚合…
阅读更多...
一站式自动化：Ansible Playbook的全面学习之旅

一站式自动化：Ansible Playbook的全面学习之旅

1 Playbook介绍 1.1 Playbook介绍 playbook 是由一个或多个play组成的列表 Playbook 文件使用YAML来写的 1.2 YAML 1.2.1 介绍 是一种表达资料序列的格式&#xff0c;类似XML Yet Another Markup Language 2001年首次发表 www.yaml.org 1.2.2 特点 可读性好 和脚本语言交…
阅读更多...
机器学习笔记 - 什么是模型量化压缩技术？

机器学习笔记 - 什么是模型量化压缩技术？

一、简述 我们都知道现实世界是连续的状态，而计算机世界是离散的状态，这是什么意思呢？我们看一下下图，最右边的马力欧（高清）的状态，可以想象现实世界是连续的状态，而电脑世界在图像上呈现的是一格一格子的状态（左图）是离散的状态。 所以在计算机世界如果想要…
阅读更多...
医疗器械设备模组的具体应用

医疗器械设备模组的具体应用

直线模组是一种高精度、高速度的精密传动元件&#xff0c;目前被广泛应用在各种工业自动化领域&#xff1b;尤其是在激光加工、电子制造、医疗设备、物流设备和机器人等行业中&#xff0c;都发挥着重要作用&#xff0c;接下来我们看看医疗器械设备模组的具体应用吧&#xff01;…
阅读更多...
智慧灯杆系统平台架构设计需要考虑的几个要点

智慧灯杆系统平台架构设计需要考虑的几个要点

智慧灯杆是一种集成了各种先进技术的道路照明设施。它不仅提供照明服务&#xff0c;还可以具有物联网技术、视频监控、环境监测、广播通讯、无线网络覆盖等多种功能。这些智能功能可以通过互联网进行控制和管理&#xff0c;从而实现智慧城市的建设。智慧灯杆能够提升城市的智能…
阅读更多...
Webgis学习总结

Webgis学习总结

前言&#xff1a; 作者跟随视频学习了webgis内容进行如下学习复习总结 参考&#xff1a;新中地学习笔记 WebGIS第一课&#xff1a;测试高德API并通过&#xff1a; 注册申请高德API成为开发者&#xff0c;创建自己的项目和key进行项目初始化&#xff0c;可以使用JS API官方文…
阅读更多...
PyQt6 QComboBox下拉组合框控件

PyQt6 QComboBox下拉组合框控件

​锋哥原创的PyQt6视频教程&#xff1a; 2024版 PyQt6 Python桌面开发 视频教程(无废话版) 玩命更新中~_哔哩哔哩_bilibili2024版 PyQt6 Python桌面开发 视频教程(无废话版) 玩命更新中~共计34条视频&#xff0c;包括&#xff1a;2024版 PyQt6 Python桌面开发 视频教程(无废话…
阅读更多...
算法基础--双指针

算法基础--双指针

前面已经写了两篇关于算法方面的文章&#xff0c;这几天想了下&#xff0c;决定把这个算法整理成一个系列&#xff0c;除了是帮助自己巩固算法知识外&#xff0c;还能够把自己总结的每种算法的套路保存下来并分享给大家&#xff0c;这样以后即使是哪天想要重拾起来&#xff0c;…
阅读更多...
Apache Doris 详细教程（三）

Apache Doris 详细教程（三）

7、监控和报警 Doris 可以使用 Prometheus 和 Grafana 进行监控和采集&#xff0c;官网下载最新版即可。 Prometheus 官网下载&#xff1a;https://prometheus.io/download/ Grafana 官网下载&#xff1a;https://grafana.com/grafana/download Doris 的监控数据通过 FE 和…
阅读更多...
排序算法介绍（四）快速排序

排序算法介绍（四）快速排序

0. 简介 快速排序&#xff08;Quick Sort&#xff09;是一种高效的排序算法&#xff0c;采用了分治的思想。它选择一个基准元素&#xff0c;通过一趟排序将待排序序列分割成独立的两部分&#xff0c;其中一部分的所有元素都比基准元素小&#xff0c;另一部分的所有元素都比基准…
阅读更多...
C++-类和对象

C++-类和对象

目录 一.C语言和C的区别 二.类的引入 三.类的定义 1.类的定义 2.类的成员方法的两种定义方式&#xff1a; 3.类的成员变量的定义 四.类的访问限定符及封装 1.访问限定符 五.面向对象的三大特征 1.面向对象的三大特征分别是什么 2.封装 六.类的作用域 七.创建类对象 1.类…
阅读更多...
【csdn默认使用操作详解】

【csdn默认使用操作详解】

这里写自定义目录标题 欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题&#xff0c;有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants 创建一个自定义列表如何创建一个…
阅读更多...
国际语音通知系统有哪些优点？国际语音通知系统有哪些应用场景?

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

国际语音通知是一种全球性的通信工具&#xff0c;它通过语音方式向用户发送各种重要信息和提示。无论是快递到货的取件提醒、机场航班的延误通知&#xff0c;还是银行账户的余额提醒&#xff0c;国际语音通知都能准确、迅速地将信息传达给用户。 三、国际语音通知系统有哪些优…
阅读更多...
qnx修改tcp和udp缓冲区默认大小

qnx修改tcp和udp缓冲区默认大小

拷贝/home/test/qnx/qos223/target/qnx7/aarch64le/sbin/sysctl进系统中 https://www.qnx.com/developers/docs/7.1/#com.qnx.doc.neutrino.utilities/topic/s/sysctl.html kern.sbmax 默认262144&#xff0c;这个限制住了发送、接收缓冲器大小 ./sysctl -w kern.sbmax10000…
阅读更多...
51单片机应用从零开始（十）·指针

51单片机应用从零开始（十）·指针

指针 C语言指针是一种保存变量地址的数据类型。它可以让程序直接访问内存中的数据&#xff0c;而不需要通过变量名来访问。指针变量存储的是一个地址&#xff0c;这个地址指向内存中的某个位置&#xff0c;该位置存储了一个值。 在C语言中&#xff0c;可以使用&运算符取得一…
阅读更多...
Siemens-NXUG二次开发-Java开发环境配置[20231203]

Siemens-NXUG二次开发-Java开发环境配置[20231203]

Siemens-NXUG二次开发-Java开发环境配置[20231203] 1.NX/UG Java API官方开发文档2.安装Java83.安装jetbrain idea3.windows系统环境变量配置4.使用idea创建项目5.NXOpen Java代码生效流程6.API体系简述6.代码示例 1.NX/UG Java API官方开发文档 西门子NX/UG Java api开发文档…
阅读更多...
严蔚敏数据结构题集 p18（2.25——2.30）（c语言代码实现）

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

目录 2.25假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合(即同一表中的元素值各不相同),现要求另辟空间构成一个线性表C,其元素为A和B中元素的交集,且表C中的元素也依值递增有序排列。试对顺序表编写求C的算法。 2.26要求同2.25题。是对单链表编写求C的算法 2.…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023