【数据结构】第2章线性表（头歌习题）【合集】

文章目录

  • 第1关：实现顺序表各种基本运算的算法
    • 任务描述
    • 编程要求
    • 完整代码
  • 第2关：实现单链表各种基本运算的算法
    • 任务描述
    • 编程要求
    • 完整代码
  • 第3关：移除顺序表中所有值等于x的元素
    • 任务描述
    • 编程要求
    • 完整代码
  • 第4关：逆置顺序表
    • 任务描述
    • 编程要求
    • 完整代码
  • 第5关：删除有序顺序表中的重复项
    • 任务描述
    • 编程要求
    • 完整代码
  • 第6关：拆分单链表
    • 任务描述
    • 相关知识
    • 编程要求
    • 完整代码
  • 第7关：删除单链表中值最大的结点
    • 任务描述
    • 编程要求
    • 测试说明
    • 完整代码
  • 第8关：单链表插入排序
    • 任务描述
    • 相关知识
    • 编程要求
    • 测试说明
    • 完整代码
  • 第9关：逆置单链表
    • 任务描述
    • 编程要求
    • 测试说明
    • 完整代码
  • 第10关：移除链表元素
    • 任务描述
    • 编程要求
    • 测试说明
    • 完整代码
  • 第11关：约瑟夫环
    • 任务描述
    • 编程要求
    • 测试说明
    • 完整代码
  • 第12关：链表的中间结点
    • 任务描述
    • 编程要求
    • 测试说明
    • 完整代码
  • 第13关：回文链表
    • 编程要求
    • 测试说明
    • 完整代码
  • 第14关：中位数
    • 任务描述
    • 编程要求
    • 测试说明
    • 完整代码
  • 第15关：合并两个有序链表
    • 任务描述
    • 编程要求
    • 测试说明
    • 提示:
    • 完整代码

第1关：实现顺序表各种基本运算的算法

任务描述

本关任务：实现顺序表各种基本运算的算法。

目的: 领会顺序表存储结构和掌握顺序表中各种基本运算算法设计。
内容: 编写程序，实现顺序表的各种基本运算和整体建表算法(假设顺序表的元素类型ElemType 为char)，并在此基础上设计一个主程序，完成如下功能:
(1)初始化顺序表L。
(2)依次插入a、b、c、d、e元素。
(3)输出顺序表L。
(4)输出顺序表L长度。
(5)判断顺序表L是否为空。
(6)输出顺序表L的第3个元素。
(7)输出元素a的位置。
(8)在第4个元素位置上插入f元素。
(9)输出顺序表L。
(10)删除顺序表L的第3个元素。
(11)输出顺序表L。
(12)释放顺序表L。

编程要求

根据提示，在右侧编辑器补充代码，完成线性表基本运算算法实现。

测试说明
平台会对你编写的代码进行测试：

输入样例：
参见题目功能说明。

输出样例：
参见题目功能说明。
整体输出顺序表时，每个数据后面一个空格。

顺序表的基本运算如下:
(1)初始化顺序表L
(2)依次插入a,b,c,d,e元素
(3)输出顺序表L:a b c d e
(4)顺序表L长度:5
(5)顺序表L为非空
(6)顺序表L的第3个元素:c
(7)元素a的位置:1
(8)在第4个元素位置上插入f元素
(9)输出顺序表L:a b c f d e
(10)删除L的第3个元素
(11)输出顺序表L:a b f d e
(12)释放顺序表L

开始你的任务吧，祝你成功！

完整代码

//顺序表运算算法
#include <stdio.h>
#include <stdlib.h>#define MaxSize 50
typedef char ElemType;typedef struct
{ElemType data[MaxSize];		//存放顺序表元素int length;					//存放顺序表的长度
} SqList;						//声明顺序表的类型/*** 初始化顺序表L。*/
void InitList(SqList * &L);/*** 释放顺序表L。*/
void DestroyList(SqList * &L);/*** 判断顺序表L是否为空表。* 空表返回true，非空表返回false。*/
bool ListEmpty(SqList * L);/*** 返回顺序表L的元素个数。*/
int ListLength(SqList * L);/*** 输出顺序表L。*/
void DispList(SqList * L);/*** 获取顺序表L中第i(1≤i≤L->length)个元素，将其值存入e，然后返回true；* 如果不能获取到第i个元素，返回false。*/
bool GetElem(SqList * L, int i, ElemType &e);/*** 在顺序表L中查找元素e。* 如果存在e，则返回e的逻辑序号，否则返回0。*/
int LocateElem(SqList * L,  ElemType e);/*** 在顺序表L中第ii(1≤i≤L->length)个位置上插入元素e。* 插入成功，返回true。插入不成功，返回false。*/
bool ListInsert(SqList * &L, int i,  ElemType e);/*** 从顺序表L中删除第ii(1≤i≤L->length)个元素。* 删除成功，返回true。删除不成功，返回false。*/
bool ListDelete(SqList * &L, int i, ElemType &e);int main()
{SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf("  (1)初始化顺序表L\n");InitList(L);printf("  (2)依次插入a,b,c,d,e元素\n");ListInsert(L, 1, 'a');ListInsert(L, 2, 'b');ListInsert(L, 3, 'c');ListInsert(L, 4, 'd');ListInsert(L, 5, 'e');printf("  (3)输出顺序表L:");DispList(L);printf("  (4)顺序表L长度:%d\n", ListLength(L));printf("  (5)顺序表L为%s\n", (ListEmpty(L) ? "空" : "非空"));GetElem(L, 3, e);printf("  (6)顺序表L的第3个元素:%c\n", e);printf("  (7)元素a的位置:%d\n", LocateElem(L, 'a'));printf("  (8)在第4个元素位置上插入f元素\n");ListInsert(L, 4, 'f');printf("  (9)输出顺序表L:");DispList(L);printf("  (10)删除L的第3个元素\n");ListDelete(L, 3, e);printf("  (11)输出顺序表L:");DispList(L);printf("  (12)释放顺序表L\n");DestroyList(L);return 0;
}/* 请在下面填写代码 */
void InitList(SqList *&L)	//初始化线性表
{/****************Begin******************/L = (SqList *)malloc(sizeof(SqList));L->length = 0;/******************End******************/
}
void DestroyList(SqList *&L)  //销毁线性表
{/****************Begin******************/free(L);/******************End******************/
}
bool ListEmpty(SqList *L)	//判线性表是否为空表
{/****************Begin******************/return (L->length==0);/******************End******************/
}
int ListLength(SqList *L)	//求线性表的长度
{/****************Begin******************/return (L->length);/******************End******************/
}
void DispList(SqList *L)	//输出线性表
{/****************Begin******************/for(int i=0; i<L->length; i++) {printf("%c ", L->data[i]);}printf("\n");/******************End******************/
}
bool GetElem(SqList *L, int i, ElemType &e)	//求线性表中第i个元素值
{/****************Begin******************/if(i<1 || i>L->length) {return false;}e=L->data[i-1];return true;/******************End******************/
}
int LocateElem(SqList *L, ElemType e)	//查找第一个值域为e的元素序号
{/****************Begin******************/int i = 0;while(i<L->length && L->data[i]!=e) {i++;}if(i>=L->length){return 0;}else{return i+1;}/******************End******************/
}
bool ListInsert(SqList *&L, int i, ElemType e)	//插入第i个元素
{/****************Begin******************/int j;if(i<1 || i>((L->length)+1) || (L->length)==MaxSize) {return false;}i--;for(j=L->length; j>i; j--) {L->data[j] = L->data[j-1];}L->data[i] = e;L->length++;return true;/******************End******************/
}
bool ListDelete(SqList *&L, int i, ElemType &e)	//删除第i个元素
{/****************Begin******************/int j;if(i<1 || i>L->length) {return false;}i--;e = L->data[i];for(j=i; j<L->length-1; j++) {L->data[j] = L->data[j+1];}L->length--;return true;/******************End******************/
}

在这里插入图片描述

第2关：实现单链表各种基本运算的算法

任务描述

本关任务：实现单链表各种基本运算的算法。

目的: 领会单链表存储结构和掌握单链表中各种基本运算算法设计。
内容: 实现单链表的各种基本运算(假设单链表的元素类型ElemType为char)，并在此基础上设计一个程序，完成如下功能:
(1)初始化单链表h。
(2)依次采用尾插法插入a、b、c、d、e元素。
(3)输出单链表h。
(4)输出单链表h长度。
(5)判断单链表h是否为空。
(6)输出单链表h的第3个元素。
(7)输出元素a的位置。
(8)在第4个元素位置上插入f元素。
(9)输出单链表h。
(10)删除单链表h的第3个元素。
(11)输出单链表h。
(12)释放单链表h。

编程要求

根据提示，在右侧编辑器Begin…End之间补充代码，实现单链表基本运算算法。

测试说明
平台会对你编写的代码进行测试：

输入样例：
参见题目功能说明。

输出样例：
参见题目功能说明。
整体输出单链表表时，每个数据后面一个空格。

单链表的基本运算如下:
(1)初始化单链表h
(2)依次采用尾插法插入a,b,c,d,e元素
(3)输出单链表h:a b c d e
(4)单链表h长度:5
(5)单链表h为非空
(6)单链表h的第3个元素:c
(7)元素a的位置:1
(8)在第4个元素位置上插入f元素
(9)输出单链表h:a b c f d e
(10)删除h的第3个元素
(11)输出单链表h:a b f d e
(12)释放单链表h

开始你的任务吧，祝你成功！

完整代码

//单链表运算算法
#include <stdio.h>
#include <stdlib.h>typedef char ElemType;typedef struct LNode {ElemType data;struct LNode *next;		//指向后继结点
} LinkNode;		 			//单链表结点类型/*** 头插法建立单链表*/
void CreateListF(LinkNode *&L, ElemType a[], int n);/*** 尾插法建立单链表*/
void CreateListR(LinkNode *&L, ElemType a[], int n);/*** 初始化线性表*/
void InitList(LinkNode *&L);/*** 销毁线性表*/
void DestroyList(LinkNode *&L);/*** 判线性表是否为空表。空表返回true，否则返回false。*/
bool ListEmpty(LinkNode *L);/*** 求线性表的长度*/
int ListLength(LinkNode *L);/*** 输出线性表: 每个数据后面一个空格*/
void DispList(LinkNode *L);/*** 求线性表中第i个元素值。* 存在第i个数据结点,其值存入e,然后返回true。* 不存在第i个数据结点,返回false。*/
bool GetElem(LinkNode *L, int i, ElemType &e);/*** 查找第一个值域为e的元素序号。* 若存在，返回其逻辑序号；若不存在，返回0。*/
int LocateElem(LinkNode *L, ElemType e);/*** 插入第i个元素。* 插入成功，返回true；插入不成功，返回false。*/
bool ListInsert(LinkNode *&L, int i, ElemType e);/*** 删除第i个元素。* 如果第i个元素存在，其值存入e，返回true；* 如果第i个元素不存在，返回false。*/
bool ListDelete(LinkNode *&L, int i, ElemType &e) ;int main() {LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf("  (1)初始化单链表h\n");InitList(h);printf("  (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(h, 1, 'a');ListInsert(h, 2, 'b');ListInsert(h, 3, 'c');ListInsert(h, 4, 'd');ListInsert(h, 5, 'e');printf("  (3)输出单链表h:");DispList(h);printf("  (4)单链表h长度:%d\n", ListLength(h));printf("  (5)单链表h为%s\n", (ListEmpty(h) ? "空" : "非空"));GetElem(h, 3, e);printf("  (6)单链表h的第3个元素:%c\n", e);printf("  (7)元素a的位置:%d\n", LocateElem(h, 'a'));printf("  (8)在第4个元素位置上插入f元素\n");ListInsert(h, 4, 'f');printf("  (9)输出单链表h:");DispList(h);printf("  (10)删除h的第3个元素\n");ListDelete(h, 3, e);printf("  (11)输出单链表h:");DispList(h);printf("  (12)释放单链表h\n");DestroyList(h);return 0;
}/* 请在下面编写程序代码 *//*** 头插法建立单链表*/
void CreateListF(LinkNode *&L, ElemType a[], int n) {/**************************Begin***************************/LinkNode *s;L = (LinkNode *)malloc(sizeof(LinkNode));  //为链表L分配内存空间，创建头结点L->next = NULL;   // 先将指向的地址为空，相当于头指针为空// 对数组处理for(int i=0; i<n; i++) {s = (LinkNode *)malloc(sizeof(LinkNode));  //为链表s分配内存空间s->data = a[i];   // 存入数据s->next = L->next;   // 指向下一节点L->next = s;  // 指向s}/***************************End****************************/
}/*** 尾插法建立单链表*/
void CreateListR(LinkNode *&L, ElemType a[], int n) {/**************************Begin***************************/LinkNode *s, *r;r = NULL;   for(int i=0; i<n; i++) {s = (LinkNode *)malloc(sizeof(LinkNode));s->data = a[i];s->next = NULL;if(r==NULL) {L = s;r = s;}else{r->next = s;r = s;}}r->next = NULL;/***************************End****************************/
}/*** 初始化线性表*/
void InitList(LinkNode *&L) {L = (LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next = NULL;				//单链表置为空表
}/*** 销毁线性表*/
void DestroyList(LinkNode *&L) {LinkNode *pre = L, *p;while (p != NULL) {p = pre->next;free(pre);pre = p;				}L = NULL;
}/*** 判线性表是否为空表。空表返回true，否则返回false。*/
bool ListEmpty(LinkNode *L) {/**************************Begin***************************/return (L == NULL);/**************************End***************************/
}/*** 求线性表的长度*/
int ListLength(LinkNode *L) {/**************************Begin***************************/int i;LinkNode *p = L;  // p指向头节点for(i=0; p->next != NULL; i++) {p = p->next;}return i;/***************************End****************************/
}/*** 输出线性表: 每个数据后面一个空格*/
void DispList(LinkNode *L) {/**************************Begin***************************/    LinkNode *p = L;	//p指向首结点while (p != NULL&&p->next!=NULL) {		//p不为NULL,输出p结点的data域       printf("%c ", p->data);p = p->next;			//p移向下一个结点}printf("\n");/***************************End****************************/
}/*** 求线性表中第i个元素值。* 存在第i个数据结点,其值存入e,然后返回true。* 不存在第i个数据结点,返回false。*/
bool GetElem(LinkNode *L, int i, ElemType &e) {/**************************Begin***************************/LinkNode *p=L;  // 从头开始遍历int count = 0;  // 用于计数当前遍历到的结点序号while (p != NULL) {count++;if (count == i) {   // 如果当前结点序号等于i，则将该结点的数据域值存入e中e = p->data;return true;}p = p->next;}return false;  // 遍历完整个链表仍然没有找到第i个元素，返回false/***************************End****************************/
}/*** 查找第一个值域为e的元素序号。* 若存在，返回其逻辑序号；若不存在，返回0。*/
int LocateElem(LinkNode *L, ElemType e) {/**************************Begin***************************/int count = 1;while (L != NULL) {if(L->data == e) {return count;}L = L->next;count++;}return 0;/***************************End****************************/
}/*** 插入第i个元素。* 插入成功，返回true；插入不成功，返回false。*/
bool ListInsert(LinkNode *&L, int i, ElemType e) {/**************************Begin***************************/if(i<1 || L==NULL) {return false;}LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));s->data = e;s->next = NULL;if(i==1) {  // 如果插入到头部s->next = L;L = s;} else {  // 如果插入到中间或尾部LinkNode *p = L;  // 当前指针结点int count = 1;while(p!=NULL&&count<i-1) {p = p->next;count++;}if(p == NULL) {return false; // 到达链表尾部，无法插入}s->next = p->next;p->next = s;}return true;  // 成功插入返回true/***************************End****************************/
}/*** 删除第i个元素。* 如果第i个元素存在，其值存入e，返回true；* 如果第i个元素不存在，返回false。*/
bool ListDelete(LinkNode *&L, int i, ElemType &e) {/**************************Begin***************************/if(L==NULL || i<1) {return false;}int count = 1;LinkNode *p = L;while(p!=NULL && count<i-1) {   p = p->next;count++;}if(p==NULL) {return false;}e = p->data;LinkNode *q = p->next;p->next = q->next;free(q);return true;/***************************End****************************/
}

在这里插入图片描述

第3关：移除顺序表中所有值等于x的元素

任务描述

本关任务：假设一个线性表采用顺序表表示，设计一个算法，删除其中所有值等于x的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。

编程要求

根据提示，在右侧编辑器补充代码，完成函数removeElems(SqList* &L, ElemType x)。

测试说明
输入
输入包括3行。
第一行为顺序表中元素的个数n。
第二行为空格隔开的n个整数。
第三行为需要删除的元素x。

输出
输出包含2行。
第一行输出顺序表所有元素，每个元素后面一个空格。
第二行为删除x后顺序表所有元素，每个元素后面一个空格。

样例输入1
10
1 2 2 1 0 2 4 2 3 1
2

样例输出1
顺序表L中的元素为: 1 2 2 1 0 2 4 2 3 1
移除 2 后顺序表L中的元素为: 1 1 0 4 3 1

样例输入2
4
3 2 2 3
3

样例输出2
顺序表L中的元素为: 3 2 2 3
移除 3 后顺序表L中的元素为: 2 2

样例输入3
8
0 1 2 2 3 0 4 2
2

样例输出3
顺序表L中的元素为: 0 1 2 2 3 0 4 2
移除 2 后顺序表L中的元素为: 0 1 3 0 4

提示
1 <= 顺序表长度 <= 100
0 <= 元素值 <= 50
0 <= x <= 100

开始你的任务吧，祝你成功！

完整代码

#include "sqlist.h"/*** 移除顺序表中值为x的所有元素*/
void removeElements(SqList *&L, ElemType x);int main()
{int n, *a, x;scanf("%d", &n);a = (int*)malloc(sizeof(int) * n);for (int i = 0; i < n; i++)scanf("%d", &a[i]);SqList *L;CreateList(L, a, n);printf("顺序表L中的元素为: "); DispList(L);scanf("%d", &x);	//输入需要移除的元素removeElements(L, x);printf("移除 %d 后顺序表L中的元素为: ", x); DispList(L);return 0;
}/*** 移除顺序表中值为x的所有元素*/
void removeElements(SqList *&L, ElemType x)
{//请在下面编写代码/***************************Begin**********************/int i=0;int j=0;while(i<L->length) {if(L->data[i]!=x) {L->data[j] = L->data[i];j++;}i++;}L->length = j;/****************************End***********************/
}

在这里插入图片描述

第4关：逆置顺序表

任务描述

在这里插入图片描述

编程要求

根据提示，在右侧编辑器补充函数rev的代码，使用顺序表L的空间就地逆置L。

测试说明
平台会对你编写的代码进行测试：

输入格式
输入包括两行。
第一行为顺序表中元素个数n。
第二行为空格隔开的n个整数。

输出格式
输出包括两行。
第一行为顺序表逆置之前的元素。每个数据后一个空格。
第二行为顺序表逆置之后的元素。每个数据后一个空格。

样例输入
5
1 2 3 4 5

样例输出
1 2 3 4 5
5 4 3 2 1

开始你的任务吧，祝你成功！

完整代码

#include <stdio.h>
#include <stdlib.h>#include "sqlist.h"/*** 就地逆置顺序表*/
void rev(SqList* &L) {//请在下面编写代码/******************Begin******************/int k;int i=0;int j=(L->length)-1;while(i<L->length/2&&i<=j) {k = L->data[i];L->data[i] = L->data[j];L->data[j] = k;i++;j--;}/*******************End*******************/
}int main(int argc, char const *argv[])
{int n;scanf("%d", &n);int *a = (int*)malloc(sizeof(int) * n);for (int i = 0; i < n; i++)scanf("%d", &a[i]);SqList* L;InitList(L);		//初始化顺序表CreateList(L, a, n);//创建顺序表DispList(L);		//输出顺序表rev(L);				//逆置顺序表DispList(L);		//输出逆置后的顺序表DestroyList(L);		//销毁顺序表free(a);			//是否数组areturn 0;
}

在这里插入图片描述

第5关：删除有序顺序表中的重复项

任务描述

本关任务：编写一个效率尽可能高的算法，删除有序顺序表中的重复元素，重复的元素只保留一个。元素的 相对顺序 应该保持 一致 。

编程要求

根据提示，在右侧编辑器补充完成函数void remove_duplicates(SqList* &L)的代码，删除有序顺序表中的重复项。

测试说明
平台会对你编写的代码进行测试：

输入格式
输入包括两行。
第一行为顺序表中元素个数n。
第二行为空格隔开的n个整数。

输出格式
输出包括两行。
第一行为有序顺序表原有的元素。每个数据后一个空格。
第二行为删除有序顺序表重复项之后的元素。每个数据后一个空格。

样例输入1
3
1 1 2

样例输出1
1 1 2
1 2

样例输入2
10
0 0 1 1 1 2 2 3 3 4

样例输出2
0 0 1 1 1 2 2 3 3 4
0 1 2 3 4

开始你的任务吧，祝你成功！

完整代码

#include <stdio.h>
#include <stdlib.h>#include "sqlist.h"/*** 删除有序顺序表中的重复项*/
void remove_duplicates(SqList* &L) {//请在下面编写代码/******************Begin******************/int k;int j=0;for(k=1; k<L->length; k++) {  // 看是否有重复的项if(L->data[j] != L->data[k]) {j++;L->data[j] = L->data[k];}}L->length = j+1;/*******************End*******************/
}int main(int argc, char const *argv[])
{int n;scanf("%d", &n);int *a = (int*)malloc(sizeof(int) * n);for (int i = 0; i < n; i++)scanf("%d", &a[i]);SqList* L;InitList(L);			//初始化顺序表CreateList(L, a, n);	//创建顺序表DispList(L);			//输出顺序表remove_duplicates(L);	//删除有序顺序表中的重复项DispList(L);			//输出顺序表DestroyList(L);			//销毁顺序表free(a);				//释放数组return 0;
}

在这里插入图片描述

第6关：拆分单链表

任务描述

在这里插入图片描述
拆分单链表
请添加图片描述

相关知识

为了完成本关任务，你需要掌握：1.单链表的基本概念，2.如何创建、遍历单链表。

单链表的基本概念
单链表是线性表的链式存储结构实现。如下图所示：
单链表
请添加图片描述
单链表的头结点
为了操作方便，有时候会在单链表第一个元素结点的前面增加一个附加头结点，如下图所示：
带附加头结点的单链表
请添加图片描述

单链表增加一个头结点的优点如下：

首结点的操作和表中其他结点的操作相一致，无需进行特殊处理；
无论链表是否为空，都有一个头结点，因此空表和非空表的处理也就统一了。

单链表结点类型定义
单链表中结点类型LinkNode的定义如下:

typedef struct LNode  //定义单链表结点类型
{  ElemType data;     //存储元素struct LNode *next; //指向后继结点
}  LinkNode;

单链表的特点
单链表的特点：当访问过一个结点 p 后，只能接着访问它的后继结点，而无法访问它的前驱结点。

单链表插入一个结点
插入操作：将值为x的新结点s插入到p结点之后。
特点：只需修改相关结点的指针域，不需要移动结点。
插入操作如下图所示：
单链表插入结点
请添加图片描述
单链表删除一个结点
删除操作：删除p结点之后的一个结点。
特点：只需修改相关结点的指针域，不需要移动结点。
删除操作如下图所示：
请添加图片描述

删除操作的语句如下：

p->next = p->next->next;

创建单链表

头插法建立单链表
从一个空表开始，创建一个头结点。
依次读取线性表中的元素，生成新结点s。
将新结点插入到当前链表的表头上，直到结束为止。
头插法建立单链表如下图所示：
请添加图片描述
建表语句如下：

void CreateListF(LinkNode *&L, ElemType a[], int n)
{LinkNode *s;L = (LinkNode *)malloc(sizeof(LinkNode));      //创建头结点L->next = NULL;for (int i = 0; i < n; i++){s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点ss->data = a[i];s->next = L->next;            //将结点s插在原开始结点之前,头结点之后L->next = s;}
}

尾插法建立单链表
从一个空表开始，创建一个头结点。
依次读取线性表中的元素，生成新结点s
将新结点插入到当前链表的表尾上，直到结束为止。
尾插法建立单链表如下图所示：
请添加图片描述
建表语句如下：

void CreateListR(LinkNode *&L, ElemType a[], int n)
{LinkNode *s, *r;L = (LinkNode *)malloc(sizeof(LinkNode));      //创建头结点L->next = NULL;r = L;                    //r始终指向终端结点,开始时指向头结点for (int i = 0; i < n; i++){s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点ss->data = a[i];r->next = s;        //将结点s插入结点r之后r = s;}r->next = NULL;            //终端结点next域置为NULL
}

输出单链表
逐一扫描单链表L的每个数据结点，并显示各结点的data域值。
请添加图片描述

编程要求

根据提示，在右侧编辑器补充代码，完成函数void split(LinkNode *&L, LinkNode *&L1, LinkNode *&L2)，将单链表L拆分为L1和L2。

测试说明
平台会对你编写的代码进行测试：

输入格式
输入包括两行。
第一行为单链表中元素个数n。
第二行为空格隔开的n个整数。

输出格式
输出包括四行。
第一行为单链表的元素。每个数据后一个空格。
第二行显示提示信息。
第三行显示单链表L1中的元素。每个数据后一个空格。
第四行显示单链表L2中的元素。每个数据后一个空格。

样例输入
6
1 2 3 4 5 6

样例输出
L: 1 2 3 4 5 6
L->L1,L2
L1: 1 3 5
L2: 6 4 2

开始你的任务吧，祝你成功！

完整代码

#include "linklist.h"//将单链表L拆分成两个单链表L1和L2。
void split(LinkNode *&L, LinkNode *&L1, LinkNode *&L2)
{//请在下面编写代码/**********************Begin**********************/LinkNode *p = L->next, *q, *r1;L1 = L;r1 = L1;   // r1指向L1的尾结点L2 = (LinkNode *)malloc(sizeof(LinkNode));L2->next = NULL;while(p!=NULL) {r1->next = p;r1 = p;p = p->next;q = p->next;p->next = L2->next;L2->next = p;p = q;}r1->next = NULL;/***********************End***********************/
}int main()
{LinkNode *L, *L1, *L2;int n;scanf("%d", &n);ElemType a[n];for (int i = 0; i < n; i++)scanf("%d", &a[i]);InitList(L);					//初始化单链表LInitList(L1);					//初始化单链表L1InitList(L2);					//初始化单链表L2CreateListR(L, a, n);			//创建单链表Lprintf("L: "); DispList(L);		//输出单链表Lprintf("L->L1,L2\n");split(L, L1, L2);				//单链表L拆分为L1和L2printf("L1: "); DispList(L1);	//输出单链表L1printf("L2: "); DispList(L2);	//输出单链表L2DestroyList(L1);				//销毁单链表L1DestroyList(L2);				//销毁单链表L2return 0;
}

在这里插入图片描述

第7关：删除单链表中值最大的结点

任务描述

本关任务：设计一个算法，删除一个单链表L中元素值最大的结点（假设最大值结点是唯一的）。

编程要求

根据提示，在右侧编辑器补充代码，完成函数void del_max_node(LinkNode *&L)，其中L为带头结点的单链表，函数功能是删除单链表L中值最大的结点。

测试说明

平台会对你编写的代码进行测试：

输入格式
输入包括两行。
第一行为单链表中元素个数n。
第二行为空格隔开的n个整数。

输出格式
输出包括两行。
第一行为单链表的元素。每个数据后一个空格。
第二行为删除值最大的元素之后的单链表。每个数据后一个空格。

样例输入1
6
3 0 2 7 8 6

样例输出1
L: 3 0 2 7 8 6
L: 3 0 2 7 6

样例输入2
1
3

样例输出2
L: 3
L: NULL

开始你的任务吧，祝你成功！

完整代码

#include "linklist.h"/*** 删除单链表中最大元素的结点。假定值最大的结点唯一。*/
void del_max_node(LinkNode *&L)
{//请在下面编写代码/******************Begin******************/LinkNode *p=L->next, *pre=L, *maxp=p, *maxpre=pre;while(p!=NULL) {if(maxp->data<p->data) {maxp = p;maxpre = pre;}pre = p;p = p->next;}maxpre->next = maxp->next;free(maxp);/*******************End*******************/
}int main()
{LinkNode *L;// int n = 10;// ElemType a[] = {1, 3, 2, 9, 0, 4, 7, 6, 5, 8};int n;scanf("%d", &n);int *a = (int*)malloc(sizeof(int) * n);for (int i = 0; i < n; i++)scanf("%d", &a[i]);CreateListR(L, a, n);		//创建单链表printf("L: "); DispList(L);	//输出单链表del_max_node(L);			//删除单链表中最大值结点printf("L: "); DispList(L);	//输出单链表DestroyList(L);				//销毁单链表free(a);					//释放数组return 0;
}

在这里插入图片描述

第8关：单链表插入排序

任务描述

本关任务：有一个带头结点的单链表L（至少有一个数据结点），设计一个算法使其元素递增有序排列。

相关知识

单链表结点类型定义：

typedef int ElemType;
typedef struct LNode
{ElemType data;struct LNode *next;        //指向后继结点
} LinkNode;                    //声明单链表结点类型

编程要求

根据提示，在右侧编辑器补充代码，完成函数void sort_list(LinkNode *&L)，该函数功能是对带头结点的单链表L进行插入排序，使其递增有序。

测试说明

平台会对你编写的代码进行测试：

输入格式
输入包括两行。
第一行为一个整数n。
第二行为空格隔开的n个整数。

输出格式
输出包括两行。
第一行为排序之前的单链表。每个数据后一个空格。
第二行为递增排序之后的单链表。每个数据后一个空格。

样例输入
10
1 3 2 9 0 4 7 6 5 8

样例输出
L: 1 3 2 9 0 4 7 6 5 8
L: 0 1 2 3 4 5 6 7 8 9

开始你的任务吧，祝你成功！

完整代码

#include "linklist.h"/*** 单链表L递增（插入）排序*/
void sort_list(LinkNode *&L)
{//请在下面编写代码/******************Begin******************/LinkNode *p, *pre, *q;p = L->next->next;L->next->next = NULL;while(p!=NULL) {q = p->next;pre = L;while(pre->next!=NULL && pre->next->data<p->data) {pre = pre->next;}p->next = pre->next;pre->next = p;p =q; }/*******************End*******************/
}int main()
{LinkNode *L;// int n = 10;// ElemType a[] = {1, 3, 2, 9, 0, 4, 7, 6, 5, 8};int n;scanf("%d", &n);int *a = (int*)malloc(sizeof(int) * n);for (int i = 0; i < n; i++)scanf("%d", &a[i]);CreateListR(L, a, n);		//创建单链表printf("L: "); DispList(L);	//输出单链表sort_list(L);				//单链表递增排序printf("L: "); DispList(L);	//输出排序后的单链表DestroyList(L);				//销毁单链表free(a);					//释放数组return 0;
}

在这里插入图片描述

第9关：逆置单链表

任务描述

在这里插入图片描述
请添加图片描述

编程要求

根据提示，在右侧编辑器补充代码，完成函数void rev_list(LinkNode *&L);该函数功能为对带头结点的单链表L进行逆置。

测试说明

平台会对你编写的代码进行测试：

输入格式
输入包括两行。
第一行为单链表中元素个数n。
第二行为空格隔开的n个整数。

输出格式
输出包括一行，为单链表逆置之后的元素。每个数据后一个空格。

样例输入
5
1 2 3 4 5

样例输出
L: 5 4 3 2 1

开始你的任务吧，祝你成功！

完整代码

#include "linklist.h"/*** 逆置单链表*/
void rev_list(LinkNode *&L)
{//请在下面编写代码/******************Begin******************/LinkNode *p, *q;  // 尾插法p = L->next;L->next = NULL;while(p!=NULL) {q = p;p = p->next;q->next = L->next;L->next = q;}/*******************End*******************/
}//尾插法建立单链表
void CreateListR(LinkNode *&L, ElemType a[], int n)
{LinkNode *s, *r;L = (LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点L->next = NULL;r = L;					//r始终指向终端结点,开始时指向头结点for (int i = 0; i < n; i++){s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点ss->data = a[i];r->next = s;		//将结点s插入结点r之后r = s;}r->next = NULL;			//终端结点next域置为NULL
}//初始化单链表
void InitList(LinkNode *&L)
{L = (LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点L->next = NULL;
}//销毁单链表
void DestroyList(LinkNode *&L)
{LinkNode *pre = L, *p = pre->next;while (p != NULL){free(pre);pre = p;p = pre->next;}free(pre);	//此时p为NULL,pre指向尾结点,释放它
}//输出单链表
void DispList(LinkNode *L)
{LinkNode *p = L->next;while (p != NULL){printf("%d ", p->data);p = p->next;}printf("\n");
}

在这里插入图片描述

第10关：移除链表元素

任务描述

本关任务：给你一个带附加头结点L的单链表和一个整数 val ，请你删除链表中所有值为 val 的结点。
例如，下图所示的单链表L，val=6，删除所有值为6的结点。
请添加图片描述

编程要求

根据提示，在右侧编辑器补充代码，完成函数void remove_elements(LinkNode *&L, ElemType val)，该函数功能为：删除L中所有值为val的结点。

测试说明

平台会对你编写的代码进行测试：

输入格式
输入包括两行。
第一行有两个空格分隔的整数。第一个整数为单链表结点数量n，第二个数为需要删除的元素val。
第二行为空格隔开的n个整数。

输出格式
输出包括一行。为删除val后的单链表，每个数据后一个空格。

样例输入
7 6
1 2 6 3 4 5 6

样例输出
L->1 2 3 4 5

开始你的任务吧，祝你成功！

完整代码

#include "linklist.h"/*** 删除链表元素: 删除L中所有值为val的结点*/
void remove_elements(LinkNode *&L, ElemType val)
{//请在下面编写代码/******************Begin******************/LinkNode *cur = L, *prev=L, *p;while(cur != NULL) {  // 遍历链表if(cur->data == val) {p = cur->next;  // 保存cur的下一个结点位置if(L == cur) {  // 判断cur是否是首结点L = p;}else{prev->next = p;  // 将cur上一节点和下一结点相连}free(cur);  // 删除等于val的结点cur = p;}else if(cur->data != val){prev = cur;cur = prev->next;  // 将cur上一结点和cur下一结点相连}}/*******************End*******************/
}//尾插法建立单链表
void CreateListR(LinkNode *&L, ElemType a[], int n)
{LinkNode *s, *r;L = (LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点L->next = NULL;r = L;					//r始终指向终端结点,开始时指向头结点for (int i = 0; i < n; i++){s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点ss->data = a[i];r->next = s;		//将结点s插入结点r之后r = s;}r->next = NULL;			//终端结点next域置为NULL
}//初始化单链表
void InitList(LinkNode *&L)
{L = (LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点L->next = NULL;
}//销毁单链表
void DestroyList(LinkNode *&L)
{LinkNode *pre = L, *p = pre->next;while (p != NULL){free(pre);pre = p;p = pre->next;}free(pre);	//此时p为NULL,pre指向尾结点,释放它
}//输出单链表
void DispList(LinkNode *L)
{if (L->next == NULL) {printf("NULL\n");return;}LinkNode *p = L->next;while (p != NULL){printf("%d ", p->data);p = p->next;}printf("\n");
}

在这里插入图片描述

第11关：约瑟夫环

任务描述

本关任务：n个人围成一圈，按顺序从1到n进行编号，初始时从编号为1的人开始按1、2、3…顺序报数，报数到m（1≤m≤n）时该人退出到圈外，接着从出圈时的下一个位置开始从1开始重新进行报数，报数到m时的人再退出到圈外，以此类推。
请按退出顺序输出每个退出人的原编号。

编程要求

根据提示，在右侧编辑器补充代码，补充完成函数void Jesuphus(LinkNode *&L, int n, int m)，其中L为不带附加头结点的循环单链表的头指针，n为圈中人的个数，m为报数的值。

测试说明

平台会对你编写的代码进行测试：

输入格式
输入只有一行，为n和m。1≤n≤3000,1≤m≤n。

输出格式
输出包含一行，为退出到圈外的人的编号，编号之间以一个空格分隔。

样例输入1
10 3

样例输出1
3 6 9 2 7 1 8 5 10 4

样例输入2
7 4

样例输出1
4 1 6 5 7 3 2

开始你的任务吧，祝你成功！

完整代码

#include "linklist.h"/*** 约瑟夫环：L为不带附带头结点的循环单链表的头指针*/
void Jesuphus(LinkNode *&L, int n, int m)
{//请在下面编写代码/******************Begin******************/LinkNode *r, *p;p = L;while(p->next!=p){for(int i=1; i<m; i++){r = p;p = p->next;}printf("%d ", p->data);r->next = p->next;p = p->next;}printf("%d", p->data);/*******************End*******************/
}//尾插法建立循环单链表
void CreateListR(LinkNode *&L, ElemType a[], int n)
{LinkNode *s, *r;L = (LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点L->data = a[0];L->next = NULL;r = L;					//r始终指向终端结点,开始时指向头结点for (int i = 1; i < n; i++){s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点ss->data = a[i];r->next = s;		//将结点s插入结点r之后r = s;}r->next = L;			//形成循环单链表
}//输出循环单链表
void DispList(LinkNode *L)
{LinkNode *p = L;while (p->next != L){printf("%d ", p->data);p = p->next;}printf("%d\n", p->data); //打印最后一个结点的值
}

在这里插入图片描述

第12关：链表的中间结点

任务描述

本关任务：给定一个头结点为 L 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

示例一：
输入：1 2 3 4 5
输出：返回的结点值为 3 。

示例二：
输入：1 2 3 4 5 6
输出：返回的结点值为 4。
由于该链表有两个中间结点，值分别为 3 和 4，我们返回第二个结点 4。

编程要求

根据提示，在右侧编辑器补充代码，完成函数LinkNode* middleNode(LinkNode *L)，该函数的功能是返回链表的中间结点。其中L为不带附加头结点的单链表的头指针。

测试说明

平台会对你编写的代码进行测试：

测试输入：
1 2 3 4 5
预期输出：
3

测试输入：
1 2 3 4 5 6
预期输出：
4

提示：给定链表的结点数介于 1 和 100 之间。

开始你的任务吧，祝你成功！

完整代码

#include "linklist.h"/*** 返回链表的中间结点。L为不带附加头结点的单链表的头指针。*/
LinkNode* middleNode(LinkNode *L)
{//请在下面编写代码/******************Begin******************/if(L->next==NULL){return L;}LinkNode *fast=L; // 走两步LinkNode *slow=L; // 走一步while(fast!=NULL && fast->next!=NULL){slow = slow->next;fast = fast->next->next;}return slow;/*******************End*******************/
}//尾插法建立不带附加头结点的单链表
void CreateListR(LinkNode *&L, ElemType a[], int n)
{LinkNode *s, *r;L = (LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点L->data = a[0];L->next = NULL;r = L;					//r始终指向终端结点,开始时指向头结点for (int i = 1; i < n; i++){s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点ss->data = a[i];r->next = s;		//将结点s插入结点r之后r = s;}r->next = NULL;			//单链表收尾
}//输出单链表
void DispList(LinkNode *L)
{LinkNode *p = L;while (p != NULL){printf("%d ", p->data);p = p->next;}printf("\n");
}

在这里插入图片描述

第13关：回文链表

任务描述
本关任务：给你一个单链表的头结点 L ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
示例一：
请添加图片描述
输出：YES

示例二：
请添加图片描述
输出：NO

编程要求

根据提示，在右侧编辑器补充代码，完成函数bool isPalindrome(LinkNode *L)，该函数功能是判断链表是否为回文链表。如果是，返回 true ；否则，返回 false 。其中 L为不带附加头结点的单链表的头指针。

测试说明

平台会对你编写的代码进行测试：

测试输入：
1 2 2 1
预期输出：
YES

测试输入：
1 2
预期输出：
NO

提示：

链表中节点数目在范围[1,10^ 3 ] 内。
0 <= Node.val <= 9。

开始你的任务吧，祝你成功！

完整代码

#include "linklist.h"/*** 判断链表是否为回文链表。如果是，返回 true ；否则，返回 false 。* L为不带附加头结点的单链表的头指针。*/
bool isPalindrome(LinkNode *L)
{//请在下面编写代码/******************Begin******************/if (L == NULL || L->next == NULL) {return true;  // 空链表或只有一个节点的链表都是回文链表}// 使用快慢指针找到链表的中间节点LinkNode *slow = L;LinkNode *fast = L;while (fast->next != NULL && fast->next->next != NULL) {slow = slow->next;fast = fast->next->next;}// 反转链表的后半部分LinkNode *prev = NULL;LinkNode *curr = slow->next;while (curr != NULL) {LinkNode *next = curr->next;curr->next = prev;prev = curr;curr = next;}// 比较前半部分和反转后的后半部分是否相等LinkNode *p1 = L;LinkNode *p2 = prev;while (p1 != NULL && p2 != NULL) {if (p1->data != p2->data) {return false;}p1 = p1->next;p2 = p2->next;}return true;/*******************End*******************/
}//尾插法建立不带附加头结点的单链表
void CreateListR(LinkNode *&L, ElemType a[], int n)
{LinkNode *s, *r;L = (LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点L->data = a[0];L->next = NULL;r = L;					//r始终指向终端结点,开始时指向头结点for (int i = 1; i < n; i++){s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点ss->data = a[i];r->next = s;		//将结点s插入结点r之后r = s;}r->next = NULL;			//单链表收尾
}//输出单链表
void DispList(LinkNode *L)
{LinkNode *p = L;while (p != NULL){printf("%d ", p->data);p = p->next;}printf("\n");
}

在这里插入图片描述

第14关：中位数

任务描述

本关任务：一个长度为L（L≥1）的升序序列S，处在第 ⌈L/2⌉个位置的数称为S的中位数。
例如：若序列S1=(11，13，15，17，19)，则S1的中位数是15。
两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2=(2，4，6，8，20)，则S1和S2的中位数是11。
现有两个等长的升序序列A和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的中位数。

编程要求

根据提示，在右侧编辑器补充代码，完成函数ElemType find_median(SqList *A, SqList *B)，该函数功能为求两个等长的有序顺序表的中位数并返回。

测试说明

平台会对你编写的代码进行测试：

测试输入：
5
11 13 15 17 19
2 4 6 8 20
预期输出：
11

开始你的任务吧，祝你成功！

完整代码

#include "sqlist.h"/*** 求两个等长的有序顺序表的中位数。*/
ElemType find_median(SqList *A, SqList *B)
{//请在下面编写代码/******************Begin******************/int i=0, j=0, k=0;while(i<A->length && j<B->length){k++;if(A->data[i] < B->data[j]){if(k==A->length)return A->data[i];i++;}else{if(k==B->length){return B->data[j];}j++;}}/*******************End*******************/
}ElemType a[MaxSize];
ElemType b[MaxSize];int main()
{SqList *L1, *L2;int n;scanf("%d", &n);for (int i = 0; i < n; i++)scanf("%d", &a[i]);for (int i = 0; i < n; i++)scanf("%d", &b[i]);CreateList(L1, a, n);CreateList(L2, b, n);printf("L1,L2的中位数:%d\n", find_median(L1, L2));return 0;
}

在这里插入图片描述

第15关：合并两个有序链表

任务描述

本关任务：将两个升序链表合并为一个新的 升序 链表。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
请添加图片描述

编程要求

根据提示，在右侧编辑器补充代码，完成函数void mergeTwoLists(LinkNode* &L, LinkNode* L1, LinkNode* L2)，该函数的功能是：合并两个有序链表。L1和L2为不带附加头结点的单链表的头指针。L为合并后的单链表的头指针。

测试说明

平台会对你编写的代码进行测试：

测试输入：
3 3
1 2 4
1 3 4
预期输出：
1 1 2 3 4 4

提示:

两个链表的节点数目范围是 [1, 1000]
L1 和 L2 均按 非递减顺序 排列。

开始你的任务吧，祝你成功！

完整代码

#include "linklist.h"/*** 合并两个有序链表。L1和L2为不带附加头结点的单链表的头指针。* L为合并后的单链表的头指针。*/
void mergeTwoLists(LinkNode* &L, LinkNode *L1, LinkNode* L2)
{//请在下面编写代码/******************Begin******************/LinkNode *p1=L1,*p2=L2,*r,*s;L=(LinkNode*)malloc(sizeof(LinkNode));r=L;while(p1!=NULL&&p2!=NULL){if(p1->data<p2->data){s=(LinkNode*)malloc(sizeof(LinkNode));s->data=p1->data;r->next=s;r=s;p1=p1->next;}else{s=(LinkNode*)malloc(sizeof(LinkNode));s->data=p2->data;r->next=s;r=s;p2=p2->next;}}while(p1!=NULL){s=(LinkNode*)malloc(sizeof(LinkNode));s->data=p1->data;r->next=s;r=s;p1=p1->next;}while(p2!=NULL){s=(LinkNode*)malloc(sizeof(LinkNode));s->data=p2->data;r->next=s;r=s;p2=p2->next;}r->next=NULL;L=L->next;/*******************End*******************/
}//尾插法建立不带附加头结点的单链表
void CreateListR(LinkNode *&L, ElemType a[], int n)
{LinkNode *s, *r;L = (LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点L->data = a[0];L->next = NULL;r = L;					//r始终指向终端结点,开始时指向头结点for (int i = 1; i < n; i++){s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点ss->data = a[i];r->next = s;		//将结点s插入结点r之后r = s;}r->next = NULL;			//单链表收尾
}//输出单链表
void DispList(LinkNode *L)
{LinkNode *p = L;while (p != NULL){printf("%d ", p->data);p = p->next;}printf("\n");
}

在这里插入图片描述

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

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

相关文章

【Kubernetes】kubectl 常用命令

【Kubernetes】kubectl 常用命令

kubectl 常用命令 1.基础命令2.部署命令3.集群管理命令4.故障诊断与调试命令5.高级命令6.设置命令7.其他命令 kubectl 是 Kubernetes 提供的命令行管理工具。通过使用 kubectl&#xff0c;可以管理和操作 Kubernetes。 1.基础命令 命令 说明 create通过文件名或标准输入创建 …
阅读更多...
Java Object浅克隆深克隆

Java Object浅克隆深克隆

对象克隆 把A对象的属性值完全拷贝给B对象&#xff0c;也叫对象拷贝&#xff0c;对象复制。 实现Cloneable接口&#xff0c;表示当前类的对象就可以被克隆&#xff0c;反之&#xff0c;表示当前类的对象就不能克隆。 如果一个接口里面没有抽象方法&#xff0c;表示当前的接口…
阅读更多...
LangChain（0.0.340）官方文档十一：Agents之Agent Types

LangChain（0.0.340）官方文档十一：Agents之Agent Types

LangChain官网、LangChain官方文档 、langchain Github、langchain API文档、llm-universe《Agent Types》、《Examples using AgentType》 文章目录 一、快速入门1.1 概念1.2 基本示例1.2.1 配置LangSmith1.2.2 使用LCEL语法创建Agents1.2.3 使用自定义runtime执行1.2.4 使用A…
阅读更多...
CentOS 7 实战指南：文件操作命令详解

CentOS 7 实战指南：文件操作命令详解

写在前面 想要快速掌握 CentOS 7 系统下的文件操作技巧吗&#xff1f;不用担心&#xff01;我为你准备了一篇详细的技术文章&#xff0c;涵盖了各种常用的文件操作命令。无论您是初学者还是有一定经验的用户&#xff0c;这篇文章都能帮助您加深对 CentOS 7 文件操作的理解&…
阅读更多...
MySQL基础入门（二）

MySQL基础入门（二）

多表内容 一对多 这个内容是黑马的入门问题&#xff0c;可以带大家思考一下这个怎么设计 我们要知道一个岗位可以对应很多用户&#xff0c;而一个用户只能对应一个岗位&#xff0c;这就属于一对多的类型 那么我们需要怎么将他们进行关联呢&#xff1f; 现在我们可以通过一个…
阅读更多...
【OpenAI Q* 超越人类的自主系统】DQN ：Q-Learning + 深度神经网络

【OpenAI Q* 超越人类的自主系统】DQN ：Q-Learning + 深度神经网络

深度 Q 网络&#xff1a;用深度神经网络&#xff0c;来近似Q函数 DQN&#xff08;深度 Q 网络&#xff09; 深度神经网络 Q-LearningQ-Learning模型结构损失函数经验回放探索策略流程关联 DQN 优化DDQN&#xff1a;双 DQN&#xff0c;实现无偏估计Dueling DQN&#xff1a;提高…
阅读更多...
Quartus的Signal Tap II的使用技巧

Quartus的Signal Tap II的使用技巧

概述&#xff1a; Signal Tap II全称Signal Tap II Logic Analyzer&#xff0c;是第二代系统级调试工具&#xff0c;它集成在Quartus II软件中&#xff0c;可以捕获和显示实时信号&#xff0c;是一款功能强大、极具实用性的FPGA片上调试工具软件。 传统的FPGA板级调试是由外接…
阅读更多...
ROS学习记录：用C++实现对wpr_simulation软件包中机器人的运动控制

ROS学习记录：用C++实现对wpr_simulation软件包中机器人的运动控制

一、在工作空间下输入catkin_make进行编译 二、在工作空间中输入source ./devel/setup.bash后回车 三、机器人的运动控制在wpr_simulation中有一个例子程序&#xff0c;在工作空间中输入&#xff1a; roslaunch wpr_simulation wpb_simple.launch后回车 四、就会启动一个仿真环…
阅读更多...
菜鸟网络Java实习一面面经

菜鸟网络Java实习一面面经

自我介绍&#xff0c;做过的项目 巴拉巴拉 你项目中用到redis&#xff0c;可以介绍一下为什么使用它吗&#xff1f; 基于内存操作&#xff0c;内存读写速度快。 支持多种数据类型&#xff0c;包括String、Hash、List、Set、ZSet等。 支持持久化。Redis支持RDB和AOF两种持久…
阅读更多...
Transformer基本结构

Transformer基本结构

Transformer基本结构 输入部分、编码部分、解码部分、输出部分 1、输入部分 原文本嵌入层及其位置编码器目标文本嵌入层及其位置编码器 位置编码器(PositionalEncoding)&#xff1a;将词汇位置不同可能会产生不同语义的信息加入到词张量中&#xff0c;以弥补位置信息的缺失 …
阅读更多...
Win10 + 4090显卡配置深度学习环境 + gaussian-splatting配置 + 实测自己的场景

Win10 + 4090显卡配置深度学习环境 + gaussian-splatting配置 + 实测自己的场景

目录 1 安装Anaconda 2023.09版本 2 安装CUDA11.8 3 安装深度学习库Cudnn8.6.0 4 安装VSCODE2019 5 安装Colmap3.8 6 安装git 7 安装Python3.10 Pytorch2.0.0 7 安装项目 8 采集数据 8.1 IPhone 14 pro 拍摄30张照片左右 做预处理 8.2 生成colmap位姿等信息 8.3 开…
阅读更多...
STM32——F407定时器概述

STM32——F407定时器概述

1 定时器分类 定时器类型数量位号位宽时钟捕获/比较输出DMA请求计数互补输出基本2TIM6,TIM716bitAPB1-有递增-通用2TIM2,TIM532bitAPB14通道有递增、递减、中心对齐-通用2TIM3,TIM432bitAPB14通道有递增、递减、中心对齐-通用1TIM916bitAPB14通道有递增-通用2TIM10、TIM1116bi…
阅读更多...
独立站的营销策略：吸引顾客的秘密武器

独立站的营销策略：吸引顾客的秘密武器

一、独立站的重要性 独立站是指企业自主建立的电子商务网站&#xff0c;具有独立的域名和运营管理权。通过独立站&#xff0c;企业可以展示产品信息、提供在线服务、进行促销活动等&#xff0c;与顾客建立互动和信任关系。独立站的重要性在于它可以帮助企业建立品牌认知度、提…
阅读更多...
面向对象基础-类与对象-封装

面向对象基础-类与对象-封装

1、类与对象 1.1 概念 类&#xff1a;类是一个抽象的概念&#xff0c;用于描述一类对象的特点。 对象&#xff1a;根据类的概念所创造的实体。 【思考】一个对象可以没有对应的类嘛&#xff1f; 不可以&#xff0c;因为必须现有类才能创建对象。 1.2 类的内容 类中最基础的内容…
阅读更多...
pygame学习(一)——pygame库的导包、初始化、窗口的设置、打印文字

pygame学习(一)——pygame库的导包、初始化、窗口的设置、打印文字

导语 pygame是一个跨平台Python库(pygame news)&#xff0c;专门用来开发游戏。pygame主要为开发、设计2D电子游戏而生&#xff0c;提供图像模块&#xff08;image&#xff09;、声音模块&#xff08;mixer&#xff09;、输入/输出&#xff08;鼠标、键盘、显示屏&#xff09;…
阅读更多...
maven中dependencyManagement标签

maven中dependencyManagement标签

简介 dependencyManagement正如其名&#xff0c;用于项目依赖的统一管理。 在父项目中的pom.xml文件中加入dependencyManagement标签即可完成依赖版本的声明。在声明完成后&#xff0c;子项目&#xff08;module&#xff09;中引用相同的依赖时可以不指定version标签自动引入…
阅读更多...
【26.4K⭐】ShareX：一款开源免费、功能强大且丰富的截屏录屏软件

【26.4K⭐】ShareX：一款开源免费、功能强大且丰富的截屏录屏软件

【26.4K⭐】ShareX&#xff1a;一款开源免费、功能强大且丰富的截屏录屏软件 在日常工作、学习和娱乐过程中&#xff0c;我们经常需要截取屏幕或者录制屏幕上特定区域中的内容并进行标记、编辑等操作。无论是为了记录重要的信息、分享有趣的内容&#xff0c;还是为了制作教程和…
阅读更多...
toto的2023年终总结

toto的2023年终总结

第一次写年终总结&#xff0c;其实顺带是把大学四年的学习都给总结了一下&#xff0c;称之为大学总结更为合适吧&#xff1f; 其实把年终总结发在CSDN上有些不适&#xff0c;之前一直想着搭一个自己的博客也因为种种事情一直没有完成&#xff0c; 索性发在这里了&#xff0c;作…
阅读更多...
20231228在Firefly的AIO-3399J开发板的Android11的Firefly的AIO-3399J开发板的DTS配置单前置摄像头ov13850

20231228在Firefly的AIO-3399J开发板的Android11的Firefly的AIO-3399J开发板的DTS配置单前置摄像头ov13850

20231228在Firefly的AIO-3399J开发板的Android11的Firefly的AIO-3399J开发板的DTS配置单前置摄像头ov13850 2023/12/28 12:30 开发板&#xff1a;Firefly的AIO-3399J【RK3399】 SDK&#xff1a;rk3399-android-11-r20211216.tar.xz【Android11】 Android11.0.tar.bz2.aa【ToyBr…
阅读更多...
unity学习笔记----游戏练习03

unity学习笔记----游戏练习03

一、修复植物种植的问题 1.当手上存在植物时&#xff0c;再次点击卡片上的植物就会在手上添加新的植物&#xff0c;需要修改成只有手上没有植物时才能再次获取到植物。需要修改AddPlant方法。 public bool AddPlant(PlantType plantType) { //防止手上出现多个植…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023