线性表章节课后习题答案集锦

目录

2.5

2.6

2.7

2.8

2.9

2.10

2.11

2.12

2.13

2.5

/*
要比较两个单词在字典中的顺序，可以逐个比较它们的字符。首先比较两个单词的第一个字符，如果相同，则继续比较下一个字符，直到找到不同的字符或者某个单词比较完毕。比较时，可以利用ASCII码进行比较，因为字母在ASCII码中是按顺序排列的。
*/
#include<stdio.h>
#include<string.h>int compareWords(char* word1, char* word2) {int len1 = strlen(word1);int len2 = strlen(word2);int minLen = len1 < len2 ? len1 : len2;//三目运算符，如果？前面的式子成立，返回：前面的值，否则返回后面的 int i;for (i = 0; i < minLen; i++) {if (word1[i] < word2[i]) {return -1; // word1在字典中排在前面} else if (word1[i] > word2[i]) {return 1; // word2在字典中排在前面}}// 如果前面的字符都相同，则长度较短的单词在字典中排在前面if (len1 < len2) {return -1;} else if (len1 > len2) {return 1;}// 两个单词相等return 0;
}int main() {char word1[] = "apple";char word2[] = "banana";int result = compareWords(word1, word2);if (result < 0) {printf("%s 在字典中排在 %s 前面\n", word1, word2);} else if (result > 0) {printf("%s 在字典中排在 %s 前面\n", word2, word1);} else {printf("%s 和 %s 相等\n", word1, word2);}return 0;
}

2.6

/*
定义两个指针，分别指向顺序表的头部和尾部。
依次交换头部和尾部指针指向的元素，直到两个指针相遇或者交叉。
当两个指针相遇或者交叉时，表就地逆置完成。
*/
#include<stdio.h>
#define MaxSize 50typedef int ElemType;
typedef struct
{ElemType data[MaxSize]; // 存放顺序表元素int length;             // 存放顺序表的长度
} SqList;                   // 顺序表的类型void InitList(SqList *L)
{L->length = 0;
}void CreateList(SqList *L, ElemType a[], int n)
{int i;for (i = 0; i < n; i++){L->data[i] = a[i];}L->length = n;
}void ReverseList(SqList *L)
{int i, temp;for (i = 0; i < L->length / 2; i++){// 交换位置i和length-i-1的元素temp = L->data[i];L->data[i] = L->data[L->length - i - 1];L->data[L->length - i - 1] = temp;}
}void DisplayList(SqList *L)
{int i; for (i = 0; i < L->length; i++){printf("%d ", L->data[i]);}printf("\n");
}int main()
{SqList L;ElemType a[] = {1, 2, 3, 4, 5};CreateList(&L, a, 5); // 创建顺序表printf("原顺序表元素：");DisplayList(&L);ReverseList(&L); // 就地逆置顺序表printf("逆置后顺序表元素：");DisplayList(&L);return 0;
}

2.7

/*根据m和n的大小选择将谁接在谁的后面，设置指针分别指向两个链表开头，从端链表的开头开始向后移动，直到移动到最后，然后末尾接在下一个链表的第一个节点，两个链表连接在一起*/
#include<stdio.h>
#include<stdlib.h>typedef struct Node {int value;struct Node* next;
} LinkList;LinkList* connect(LinkList* ha, LinkList* hb, int m, int n) {LinkList* hc, *rear;if (m >= n) {hc = hb;rear = ha;}else {hc = ha;rear = hb;}LinkList* head = hc;while (hc->next != NULL) {hc = hc->next;}hc->next = rear->next;ha = hb = NULL;return head;
}LinkList* createList(int arr[], int n) {LinkList* rear;LinkList* l = (LinkList*)malloc(sizeof(LinkList));rear = l;int i;for (i = 0; i < n; i++) {LinkList* tmp = (LinkList*)malloc(sizeof(LinkList));tmp->value = arr[i];rear->next = tmp;rear = rear->next;}rear->next = NULL;return l;
}int main() {int a[] = { 1,5,6,2,1,7 };int b[] = { 7,3,12,2,9,8,11 };LinkList* l1 = createList(a, sizeof(a) / sizeof(a[0]));LinkList* l2 = createList(b, sizeof(b) / sizeof(b[0]));LinkList* l = connect(l1, l2, sizeof(a) / sizeof(a[0]), sizeof(b) / sizeof(b[0]));l = l->next;while (l != NULL) {printf("%d ", l->value);l = l->next;}return 0;
}

2.8

/*定义指针分别指向两个链表的开头，以及开头的下一个元素，然后使用一个指针在两个链表之间交叉移动，将两个链表串起来*/
#include<stdio.h>
#include<stdlib.h>
#define error -1;
#define OK 1;typedef int ElemType;//typedef表示重命名 
typedef int status;typedef struct LNode
{ElemType data;struct LNode *next;
}LNode, *LinkList;LinkList creat()
{//使用尾插法建立带头结点的单链表；LinkList L;L = (LinkList)malloc(sizeof(LNode));    //开辟头结点空间if(!L){printf("memory malloc error!\n");}LinkList p = L;ElemType a;int len;printf("请输入待建表的表长：");scanf("%d", &len);if(len>0){int i;for(i=0; i<len; i++){   printf("请输入第%d个元素的值:", i+1);scanf("%d", &a);p->next = (LinkList)malloc(sizeof(LNode));p->next->data = a;p = p->next;}}p->next = NULL;return L;
}void print(LinkList L)
{LinkList p = L ->next;while(p != NULL){printf("%d\n", p->data);p = p->next;}
}
LinkList mix_connect(LinkList A, LinkList B)
{//A,B均为带头结点的单链表，长度均未显式存储if(A->next == NULL && B->next == NULL)return NULL;else{LinkList p = A->next;LinkList q = B->next;LinkList C = A; C->next = NULL;LinkList s = C; free(B);while(p != NULL && q != NULL){s->next = p;p = p->next;s = s->next;s->next = q;q = q->next;s = s->next;}if(p != NULL)s->next = p;if(q != NULL)s->next = q;    //这两个if只会执行其中一个return C;}
}
int main()
{LinkList A = creat();LinkList B = creat();LinkList C=mix_connect(A, B);print(C);return 0;
}

2.9

/*
创建三个循环链表，分别用于存放字母字符、数字字符和其它键盘字符。
遍历原链表，将不同类别的字符按照类别链接到对应的循环链表中。
遍历完成后，将每个循环链表的尾节点的 next 指针指向头节点，形成循环链表。
*/
#include<stdio.h>
#include<stdlib.h>typedef struct Node {char data;struct Node* next;
} Node, *LinkList;void splitList(LinkList L, LinkList* alphabetList, LinkList* digitList, LinkList* otherList) {//遍历原链表，将不同类别的字符按照类别链接到对应的循环链表中。Node *p = L->next, *q, *r, *s, *t, *u;*alphabetList = (LinkList)malloc(sizeof(Node));*digitList = (LinkList)malloc(sizeof(Node));*otherList = (LinkList)malloc(sizeof(Node));(*alphabetList)->next = (*digitList)->next = (*otherList)->next = NULL;q = *alphabetList;r = *digitList;s = *otherList;while (p != NULL) {if ((p->data >= 'a' && p->data <= 'z') || (p->data >= 'A' && p->data <= 'Z')) {q->next = p;q = p;} else if (p->data >= '0' && p->data <= '9') {r->next = p;r = p;} else {s->next = p;s = p;}p = p->next;}q->next = (*alphabetList)->next;r->next = (*digitList)->next;s->next = (*otherList)->next;// 移除哑结点，并连接头指针到第一个有效节点上*alphabetList = (*alphabetList)->next;*digitList = (*digitList)->next;*otherList = (*otherList)->next;// 将最后一个节点的next指针置为NULL，避免环形链表q->next = NULL;r->next = NULL;s->next = NULL;
}void printList(LinkList L) {Node* p = L;while (p != NULL) {printf("%c ", p->data);p = p->next;}printf("\n");
}int main() {char chars[] = "a1b2c3!@#d4";LinkList L = (LinkList)malloc(sizeof(Node));Node* p = L;int i;for (i = 0; i < sizeof(chars) / sizeof(chars[0]); i++) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = chars[i];newNode->next = NULL;p->next = newNode;p = newNode;}LinkList alphabetList, digitList, otherList;//分别表示字母，数字和其它 splitList(L, &alphabetList, &digitList, &otherList);printf("Alphabet List: ");printList(alphabetList);printf("Digit List: ");printList(digitList);printf("Other List: ");printList(otherList);return 0;
}

2.10

#include<stdio.h>typedef int ElemType;
typedef struct DuLNode{ElemType data;struct DuLNode *prior;struct DuLNode *next;
} DuLNode, *DuLinkList;//初始化双向循环链表(头节点)
DuLinkList InitDuLinkList()
{DuLNode *dnode = (DuLNode *)malloc(sizeof(DuLNode));dnode->data = 0;dnode->prior = dnode;dnode->next = dnode;return dnode;
}
//创建链表元素
void CreateDuLinkList(DuLinkList L, ElemType *arr, int n)
{DuLNode *dnode;DuLNode *p = L;int i;for (i = 0; i < n; i++){dnode = (DuLNode *)malloc(sizeof(DuLNode));dnode->data = arr[i];dnode->next = L;dnode->prior = p;p->next = dnode;p = p->next;}
}
//输出链表
void ShowList(DuLinkList L)
{int i;DuLNode *r = L->next;while (r->next != L){printf("%d ", r->data);r = r->next;}printf("%d ", r->data);printf("\n");
}/*
将L中的元素，按如下规则插入新表，并返回新表。
（1,2）->(1,3,2)->(1,3,4,2)->(1,3,5,4,2)->(1,3,5,6,4,2)->...
*/
DuLinkList Transform(DuLinkList L)
{DuLinkList Lnew = InitDuLinkList();DuLNode *p, *q, *pa, *pb;q = p = L->next;pa = pb = Lnew;while (p != L){if (p != L){/*L中寄数个数据插入Lnew*/q = p->next;//保留 L 链表//pa之后插入pp->prior = pa;pa->next = p;p->next = pb;pb->prior = p;pa = pa->next;p = q;//p指向 待操作 L}if (p != L){/*L中偶数个数据插入Lnew*/q = p->next;//保留 L 链表//pb之前插入pp->next = pb;pb->prior = p;p->prior = pa;pa->next = p;pb = pb->prior;p = q;//p指向 待操作 L}}return Lnew;
}int main()
{ElemType data[7] = { 1, 2, 3, 4, 5, 6, 7 };//测试数据1（奇数个）//ElemType data[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };//测试数据2（偶数个）int length = sizeof(data) / sizeof(ElemType);DuLinkList L = InitDuLinkList(), Lnew;CreateDuLinkList(L, data, length);printf("原链表：");ShowList(L);Lnew = Transform(L);printf("改造表：");ShowList(Lnew);getchar();return 0;
}

2.11

/*从最小的位置开始，将后面的数据依次往前赋值，然后指针向后移动*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>typedef struct node
{int data;//数据int length;//长度struct node  *next;
}Node,*LinkList;
//删除超过范围的内容
void deLinkList(LinkList L,int mink,int maxk)
{LinkList p,q;p=L;while(p!=NULL){if(p->data>mink&&p->data<maxk){printf("找到错误目标\n");q=p->next;p->data=q->data;p->next=q->next;free(q);}else p=p->next;}
}
//得到要输入的数据数量
int getnumber()
{int n;printf("请输入你要录入的数据数量：");scanf("%d",&n);return n;
}/*建立链表
后插入法创造链表
算法时间复杂度为O(n)
*/
LinkList init(int n)
{int i;LinkList L;Node *r;Node *p;L=(LinkList)malloc(sizeof(Node));//建立一个带头指针的空链表L->next=NULL;r=L;//尾指针r指向头结点for(i=1;i<=n;i++){p=(Node *)malloc(sizeof(Node));//生成新结点printf("输入第%d位的数据：",i);//输入元素值赋给新结点*p的数据域scanf("%d",&p->data);p->next=NULL;//将新结点*p插入尾结点*r之后r->next=p;//r指向新的尾结点*pr=p;}L->length=n;return L;
}
//展示信息
//算法的时间复杂度未O(n),n为单链表中的数据节点的个数
void show(LinkList L)
{int i=0;Node *p;p=L->next;while(p){i++;printf("第%d位的数据:%d\n",i,p->data);p=p->next;}printf("\n信息已全部输出\n");}
//主函数
int main()
{int n,mink,maxk;LinkList L;n=getnumber();L=init(n);show(L);//删除mink~maxk之间的元素printf("请输入mink、maxk的值\n");scanf("%d%d",&mink,&maxk);deLinkList(L,mink,maxk);show(L);free(L);
}

2.12

#include<stdio.h>
#include<stdlib.h>typedef struct LNode
{int data;struct LNode *next;
}LNode, *LinkList;int InitList(LinkList *L)
{*L = (LinkList)malloc(sizeof(LNode));(*L)->next = NULL;return 0;
}int CreateList(LinkList *L, int e)
{LinkList p = *L;while(p->next)p = p->next;LinkList temp = (LinkList)malloc(sizeof(LNode));temp->data = e;temp->next = NULL;p->next = temp;return 0;
}int DispList(LinkList *L)
{LinkList p = (*L)->next;while(p){printf("%d\t", p->data);p = p->next;}return 0;
}int ListOppose(LinkList *L)
{LinkList q, p, s;p = *L;p = p->next;(*L)->next = NULL;while(p){q = p;p = p->next;q->next = (*L)->next;(*L)->next = q;}return 0;
}int ListMerge(LinkList *A, LinkList *B, LinkList *C)
{LinkList qa, pa, pb, qb;pa = *A;  qa = pa;   pa = pa->next;pb = (*B)->next;*C = *A;while(pa && pb){if(pa->data <= pb->data){qb = pb;pb = pb->next;qb->next = qa->next;qa->next = qb;qa = qa->next;}else{qb = pb;pb = pb->next;qb->next = pa->next;pa->next = qb;pa = pa->next;}}free(*B);return 0;
}int main()
{LinkList A, B, C;InitList(&A);    InitList(&B);int i;for(i = 1; i< 6; i++)CreateList(&A, i);int j;for(j = 4; j < 11; j++)CreateList(&B, j);printf("\nA 链表为:\n");DispList(&A);printf("\nB 链表为:\n");DispList(&B);printf("\nC 链表为:\n");ListOppose(&A);ListOppose(&B);printf("\n逆置后的 A 链表为:\n");DispList(&A);printf("\n逆置后的 B 链表为:\n");DispList(&B);ListMerge(&A, &B, &C);printf("\n合并后的 C 链表为:\n");DispList(&C);return 0;
}

2.13

#include<stdio.h>
#include<stdlib.h>typedef struct {int* data; // 存放元素的数组int length; // 当前长度int maxSize; // 最大长度
} SqList;// 初始化顺序表
void initList(SqList* list, int maxSize) {list->data = (int*)malloc(maxSize * sizeof(int));list->length = 0;list->maxSize = maxSize;
}// 在顺序表中查找元素的位置，返回位置下标
int locateElem(SqList* list, int elem) {int i;for (i = 0; i < list->length; i++) {if (list->data[i] == elem) {return i;}}return -1; // 找不到返回-1
}// 添加元素到顺序表的末尾
void addElem(SqList* list, int elem) {if (list->length < list->maxSize) {list->data[list->length++] = elem;}
}// 求A和B的交集，结果保存在C中
void intersection(SqList* A, SqList* B, SqList* C) {int i = 0, j = 0;while (i < A->length && j < B->length) {if (A->data[i] == B->data[j]) {addElem(C, A->data[i]);i++;j++;} else if (A->data[i] < B->data[j]) {i++;} else {j++;}}
}// 打印顺序表的元素
void printList(SqList* list) {int i;for (i = 0; i < list->length; i++) {printf("%d ", list->data[i]);}printf("\n");
}int main() {SqList A, B, C;int maxSize = 10; // 假设最大长度为10initList(&A, maxSize);initList(&B, maxSize);initList(&C, maxSize);// 假设A和B的元素是有序且不重复的int a[] = {1, 3, 5, 7, 9};int b[] = {3, 4, 5, 6, 7};int i;for (i = 0; i < sizeof(a) / sizeof(a[0]); i++) {addElem(&A, a[i]);}int j;for (j = 0; j < sizeof(b) / sizeof(b[0]); j++) {addElem(&B, b[j]);}printf("集合A：");printList(&A);printf("集合B：");printList(&B);intersection(&A, &B, &C);printf("集合C（A和B的交集）：");printList(&C);free(A.data);free(B.data);free(C.data);return 0;
}

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

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

相关文章

IO流——打印流

IO流——打印流

PrintStream/PrintWriter(打印流) 作用&#xff1a;打印流可以更方便、更高效地将数据打印出去&#xff0c;能实现打印啥就出去啥 PrintStream提供地打印数据的方案 构造器说明public PrintStream​(OutputStream/File/String)打印流直接通向字节输出流/文件/文件路径publi…
阅读更多...
Go-知识select

Go-知识select

Go-知识select 1. select 的特性1.1 chan读写1.2 返回值1.3 default 2. select 经典使用2.1 永久阻塞2.2 快速检错2.3 限时等待 3. 实现原理3.1 数据结构3.2 实现逻辑3.3 原理总结 4. 总结4.1 大概原理4.2 参数4.3 返回值 一个小活动&#xff1a; https://developer.aliyun.com…
阅读更多...
springboot基于SpringBoot的学生请假管理系统的设计与实现

springboot基于SpringBoot的学生请假管理系统的设计与实现

摘 要 系统根据现有的管理模块进行开发和扩展&#xff0c;采用面向对象的开发的思想和结构化的开发方法对学生请假管理的现状进行系统调查。采用结构化的分析设计&#xff0c;该方法要求结合一定的图表&#xff0c;在模块化的基础上进行系统的开发工作。在设计中采用“自下而上…
阅读更多...
江科大stm32学习笔记【6-2】——定时器定时中断定时器外部时钟

江科大stm32学习笔记【6-2】——定时器定时中断定时器外部时钟

一.定时器定时中断 1.原理 2.硬件 3.程序 此时CK_PSC72M&#xff0c;定时1s&#xff0c;也就是定时频率为1Hz&#xff0c;所以可以PSC7200-1,ARR10000-1。 Timer.c: #include "stm32f10x.h" // Device headerextern uint16_t Num;//声明跨文件的…
阅读更多...
力扣经典题：分割平衡字符串

力扣经典题：分割平衡字符串

大佬的代码非常简洁 int balancedStringSplit(char * s){short i0,count0,sign0;while(s[i]){signs[i]L?sign1:sign-1;if(sign0) count;}return count; }
阅读更多...
Python最常用的库

Python最常用的库

本文章主要为大家总结&#xff0c;9个Python最常用的包及使用案例 1 NumPy 描述: NumPy 是 Python 的一个扩展库&#xff0c;支持高维数组与矩阵运算&#xff0c;并为数组运算提供了大量的数学函数库。它是科学计算中的基础包之一&#xff0c;用于处理大型多维数组和矩阵的运…
阅读更多...
Transformer代码从零解读【Pytorch官方版本】

Transformer代码从零解读【Pytorch官方版本】

文章目录 1、Transformer大致有3大应用2、Transformer的整体结构图3、如何处理batch-size句子长度不一致问题4、MultiHeadAttention&#xff08;多头注意力机制&#xff09;5、前馈神经网络6、Encoder中的输入masked7、完整代码补充知识&#xff1a; 1、Transformer大致有3大应…
阅读更多...
第十四届蓝桥杯省赛真题 Java A 组【原卷】

第十四届蓝桥杯省赛真题 Java A 组【原卷】

文章目录 发现宝藏【考生须知】试题 A \mathrm{A} A : 特殊日期试题 B: 与或异或试题 C : \mathrm{C}: C: 平均试题 D: 棋盘试题 E : \mathrm{E}: E: 互质数的个数试题 F: 阶乘的和试题 G: 小蓝的旅行计划试题 H: 太阳试题 I: 高塔试题 J \mathrm{J} J : 反异或 01 串 发现…
阅读更多...
ChatGPT编程—实现小工具软件(批量替换文本、批量处理图像文件)

ChatGPT编程—实现小工具软件(批量替换文本、批量处理图像文件)

ChatGPT编程—实现小工具软件(批量替换文本、批量处理图像文件) 今天借助[小蜜蜂AI][https://zglg.work]网站的ChatGPT编程实现一个功能&#xff1a;批量处理文件及其内容&#xff0c;例如批量替换文本、批量处理图像文件等。 环境&#xff1a;Pycharm 2021 系统&#xff1a…
阅读更多...
NVENC 视频编码器 API 编程指南 ( 中文转译 )

NVENC 视频编码器 API 编程指南 ( 中文转译 )

基于 NVIDIA Kepler™ 和更高版本 GPU 架构的 NVIDIA GPU 包含基于硬件的 H.264/HEVC/AV1 视频编码器&#xff08;以下简称 NVENC&#xff09;。NVENC 硬件采用 YUV/RGB 作为输入&#xff0c;并生成符合H.264/HEVC/AV1 标准的视频比特流。可以使用 NVIDIA 视频编解码器 SDK 中提…
阅读更多...
挑战杯 机器视觉人体跌倒检测系统 - opencv python

挑战杯 机器视觉人体跌倒检测系统 - opencv python

0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 机器视觉人体跌倒检测系统 该项目较为新颖&#xff0c;适合作为竞赛课题方向&#xff0c;学长非常推荐&#xff01; &#x1f947;学长这里给一个题目综合评分(每项满分5分) 难度系数&…
阅读更多...
蓝桥：硬币兑换（python）

蓝桥：硬币兑换（python）

问题描述&#xff1a; 小蓝手中有2023种不同面值的硬币,这些硬币全部是新版硬币,其中第i(1≤i≤2023)种硬币的面值为i,数量他为i个。硬币兑换机可以进行硬币兑换&#xff0c;兑换规则为:交给硬币兑换机两个新版硬币coin1和coin2,硬币兑换机会兑换成一个面值为coin1十coin2的旧…
阅读更多...
使用C语言计算1/1-1/2+1/3-1/4+...+1/99-1/100

使用C语言计算1/1-1/2+1/3-1/4+...+1/99-1/100

观察算式&#xff0c;发现分子都是1&#xff0c;分母从1~100&#xff0c;所以可以使用for循环产生1~100之间的数。 另一个问题是&#xff0c;如何产生正负交替的符号&#xff1f;很简单&#xff0c;这个符号本质上就是往每一项前面乘一个系数&#xff1a;一或者负一。所以只需…
阅读更多...
008：安装Docker

008：安装Docker

安装Docker 如果不太熟悉Linux命令&#xff0c;不想学习Linux命令&#xff0c;可以直接看文末NAS面板章节&#xff0c;通过面板&#xff0c;像使用Window一样操作NAS。 一、安装 Docker 1.安装 Docker wget -qO- https://get.docker.com/ | sh2.启动 Docker 服务 sudo sys…
阅读更多...
CMake官方教程6--为仪表加入测试支持

CMake官方教程6--为仪表加入测试支持

1. 测试支持 cmake_minimum_required(VERSION 3.15)# set the project name and version project(Tutorial VERSION 1.0)# specify the C standard add_library(tutorial_compiler_flags INTERFACE) target_compile_features(tutorial_compiler_flags INTERFACE cxx_std_11)# …
阅读更多...
算法练习：二分查找

算法练习：二分查找

目录 1. 朴素二分查找2. 在排序数组中查找元素的第一个和最后一个位置3. 搜索插入位置4. x的平方根5. 山脉数组的峰值索引6. 寻找峰值7. 寻找旋转排序数组中的最小值8. 点名 1. 朴素二分查找 题目信息&#xff1a; 题目链接&#xff1a; 二分查找二分查找的使用前提为数据具有&…
阅读更多...
人脸相关数据集（检测，活体，关键点，表情等等）

人脸相关数据集（检测，活体，关键点，表情等等）

参考&#xff1a; 【笔记】人脸处理相关数据集 - 知乎
阅读更多...
【Vue】首屏加载优化

【Vue】首屏加载优化

文章目录 1. 使用路由懒加载2. 使用异步组件3. 精灵图雪碧图4. 使用webp格式图片5. 添加loading效果6. 事先设置图片宽高7. 配置webpack8. 利用CDN加速资源9. 延迟加载不重要的资源10. 服务器端渲染 1. 使用路由懒加载 首屏进入时只加载首屏相关路由&#xff0c;其他路由实现懒…
阅读更多...
掌握高级设计原则：Java中的过滤器模式解析与实战演练，构建灵活且可扩展的系统架构

掌握高级设计原则：Java中的过滤器模式解析与实战演练，构建灵活且可扩展的系统架构

过滤器模式是一种结构型设计模式&#xff0c;它允许开发者使用不同的标准来过滤一组对象&#xff0c;并通过逻辑运算以解耦的方式将它们联系起来。 过滤器模式的核心在于提供了一个处理对象的机制&#xff0c;这个机制可以根据一个或多个标准来决定哪些对象应该被接受、哪些应…
阅读更多...
解析KafkaConsumer类的神奇之道

解析KafkaConsumer类的神奇之道

欢迎来到我的博客&#xff0c;代码的世界里&#xff0c;每一行都是一个故事 解析KafkaConsumer类的神奇之道 前言KafkaConsumer双线程设计主线程&#xff08;消费线程&#xff09;&#xff1a;心跳线程&#xff1a;示例代码&#xff1a; KafkaConsumer线程不安全线程安全的替代…
阅读更多...
最新文章

Copyright @ 2022~2023