C语言手撕实战代码_循环单链表和循环双链表

news2024/11/25 6:35:29

C语言手撕实战代码_循环单链表和循环双链表

循环单链表习题
1.建立带头结点的循环链表
2.设计一个算法，将一个带有头结点的循环单链表中所有结点的链接方向逆转
3.设计一个算法,将一个循环单链表左移k个结点
4.设计一个算法将循环单链表中的结点p的直接前驱删除
5.设计算法将一个含有数字，字母和其他字符组成的循环链表拆分成为三个循环链表，每条链中只包含一种类型的字符。
6.设计一个算法，将单链表中从第 i 个节点到第 m 个节点之间的节点顺序逆置，并将逆置后的子链表变成一个循环链表
7.已知La和Lb分别为两个循环单链表的头节点指针，m和n分别为La和Lb中数据结点的个数，设计时间复杂度最小的算法将两个链表合并成一个带头的循环单链表
8.创建尾指针指向的循环单链表
9.请设计一种数据结构来存储带头结点指针，m和n分别为La和Lb中数据节点的个数，设计时间复杂度最小的算法将两个链表合并成一个带头的循环单链表。
双链表和循环双链表实践
1.双链表的建立
2.双链表的前趋遍历和后继遍历
3.实践双链表:请你设计一个算法，将带头双向链表中数据结点的原有顺序保存在每个结点的next域中，而prior域将所有结点按照其值从小到大的顺序链接起来
4.实践循环双链表:设以头结点得双向循环链表表示得线性表为L=(a1，a2,a3，…,an)。试写一时间复杂度为o(n)的算法，将L改造为L(a1,a3,an,a4,a2)

文章目录

  • C语言手撕实战代码_循环单链表和循环双链表
  • 循环单链表实践
    • 1.建立带头结点的循环链表
    • 2.设计一个算法，将一个带有头结点的循环单链表中所有结点的链接方向逆转
    • 3.设计一个算法,将一个循环单链表左移k个结点
    • 4.设计一个算法将循环单链表中的结点p的直接前驱删除
    • 5.设计算法将一个含有数字，字母和其他字符组成的循环链表拆分成为三个循环链表，每条链中只包含一种类型的字符。
    • 6.设计一个算法，将单链表中从第 i 个节点到第 m 个节点之间的节点顺序逆置，并将逆置后的子链表变成一个循环链表
    • 7.已知La和Lb分别为两个循环单链表的==头节点指针==，m和n分别为La和Lb中数据结点的个数，设计时间复杂度最小的算法将两个链表合并成一个带头的循环单链表
    • 8.创建尾指针指向的循环单链表
    • 9.请设计一种数据结构来存储带头结点指针，m和n分别为La和Lb中数据节点的个数，设计时间复杂度最小的算法将两个链表合并成一个带头的循环单链表。
  • 双链表和循环双链表实践
    • 1.双链表的建立
    • 2.双链表的前趋遍历和后继遍历
    • 3.实践双链表:请你设计一个算法，将带头双向链表中数据结点的原有顺序保存在每个结点的next域中，而prior域将所有结点按照其值从小到大的顺序链接起来
    • 4.实践循环双链表:设以头结点得双向循环链表表示得线性表为L=(a~1~，a~2~,a~3~，...,a~n~)。试写一时间复杂度为o(n)的算法，将L改造为L(a~1~,a~3~,a~n~,a~4~,a~2~)

循环单链表实践

1.建立带头结点的循环链表

思路:在原有带头结点单链表的基础上，让尾部指向头结点，因为要操作尾部，所以使用尾插法建立。
其实就是用尾插法在结尾处让原本指向空的指针，指向头结点

void creat_cyclelinklist_byinserttail(LinkList &L,int enterArra[],int enterArraLength)
{
    //先定义头结点
    L=(LinkNode *)malloc(sizeof(LinkNode));
    L->next=NULL;
    
    //循环尾插结点
    int index=0; //第一个数组下标
    LinkList tail=L;
    while(index<enterArraLength)
    {
        LinkNode *p=(LinkNode *)malloc(sizeof(LinkNode));
        p->data= enterArra[index++];
        tail->next=p;
        tail=p;
    }
    tail->next=L;
}

就是把
tail->next=NULL;改成了tail->next=L;
验证建立带头结点的循环链表，循环12次，看看输出的链表

    int c[8]={1,2,3,4,5,6,7,8};
    LinkList Lc=NULL;
    creat_cyclelinklist_byinserttail(Lc, c, 8);
    int x=12;
    LinkNode *p=Lc;
    while (x--) {
        printf("%d->",p->next->data);
        p=p->next;
    }
    printf("NULL\n");

在这里插入图片描述

2.设计一个算法，将一个带有头结点的循环单链表中所有结点的链接方向逆转

思路:循环单链表的逆转其实和单链表的逆转并无差别，还是用pre和cur指针再配一个临时p指针，主要注意一下，最后反转完还是循环的就行。

总结:循环单链表反转=单链表反转+处理头结点反转

void reverse_cryleLinklist(LinkList &Lc)
{
    LinkNode *cur=Lc->next; //指向第一个元素
    LinkNode *pre=Lc; //指向头结点
    LinkNode *p=NULL;
    while(p!=Lc)
    {
        p=cur->next;
        cur->next=pre;
        pre=cur;
        cur=p;
    }     //这里结束，意味着除了头结点之外都反转过来了，即完成了单链表的反转操作
    Lc->next=pre; //最后一步，完成了头结点的反转
}

3.设计一个算法,将一个循环单链表左移k个结点

左移简单理解就是，原先的循环一遍的顺序是12345,左移两位之后，循环的顺序就是34512.也就是头结点右移

不需要引入新的头结点的方式。
需要找到链表尾部，头结点插入的前一个位置，插入的后一个位置，

找到待插入结点和它的前一个结点。还有最后一个结点，然后将新的头结点插入，将最后一个结点指向第一个结点。

void left_crycle_linklist(LinkList &Lc,int k)
{
    //找到三个点 pre cur last,记录一个点 first,第一个结点的位置
    LinkNode *pre=Lc;
    LinkNode *cur=Lc->next;
    LinkNode *last=Lc;
    LinkNode *first=Lc->next;
    //第一个循环找pre和cur
    while (k--) {
        cur=cur->next;
        pre=pre->next;
    }
    //第二个循环找last
    while(last->next!=Lc)
    {
        last=last->next;
    }
    
    //将头结点插入
    Lc->next=cur;
    pre->next=Lc;
    //将最后一个结点连接第一个结点
    last->next=first;
}

思考:我记得单链表中还是使用反转链表做的，但是循环链表就不用那么复杂。

4.设计一个算法将循环单链表中的结点p的直接前驱删除

思路：给你一个指向p结点的指针P，设置一个寻找指针find，和新的指向p的指针new_p,find指向P的后继的后继。new_p和find构成双指针移动。find再次指向p的时候，new_p就指向了我们的目标，然后进行删除就ok。
在这里插入图片描述

5.设计算法将一个含有数字，字母和其他字符组成的循环链表拆分成为三个循环链表，每条链中只包含一种类型的字符。

思路:创建三个循环链表，采用头插法加入链表，重点在于判断三种类型。
数字0的asc码是48，数字0到9是连续的，故9的asc码是48+9=57
大写字母A的asc码是65，故大写字母Z的asc码是65+25=90
小写字母a是asc码是97，故小写字母z的asc码是97+25=122

6.设计一个算法，将单链表中从第 i 个节点到第 m 个节点之间的节点顺序逆置，并将逆置后的子链表变成一个循环链表

逻辑很清晰，先逆置，最后操作形成循环链表
值得注意的是，这个操作之后，m结点之后的结点将无法被访问到。

给出图例:
在这里插入图片描述

7.已知La和Lb分别为两个循环单链表的头节点指针，m和n分别为La和Lb中数据结点的个数，设计时间复杂度最小的算法将两个链表合并成一个带头的循环单链表

思路很简单，将较短的循环单链表插入较长的循环单链表中，采用头插法。

注意和第9题联系起来

8.创建尾指针指向的循环单链表

本质就是，尾插法建立循环单链表，记录好最后一个元素，处理好循环。
非常值得注意的是此时La和Lb 是指向最后一个结点，假如你要找到头结点
La->next才是头结点
在这里插入图片描述
在这里插入图片描述

9.请设计一种数据结构来存储带头结点指针，m和n分别为La和Lb中数据节点的个数，设计时间复杂度最小的算法将两个链表合并成一个带头的循环单链表。

在这里插入图片描述
其中pheadLa是这么定义的，pheadLa=Ta->next。

双链表和循环双链表实践

1.双链表的建立

使用头插法建立双链表，在插入过程中，先连接插入结点，再更新插入结点的前驱结点和后继结点。注意后继结点一定要判空，否则会访问出界。

typedef  int ElemType;
typedef struct DuLinkNode
{
    ElemType data;
    struct DuLinkNode* prior;
    struct DuLinkNode* next;
}DuLinkNode,*DuLinkList;


void creat_doubleLinklist(DuLinkList &DL, int a[4],int length) //双链表的建立
{
    //创建一个头结点
    DL=(DuLinkNode *)malloc(sizeof(DuLinkNode));
    DL->next=NULL;
    DL->prior=NULL;
    
    DuLinkNode * L=DL;
    //添加结点
    for(int i=0;i<length;i++)
    {
        DuLinkNode * p;
        p=(DuLinkNode *)malloc(sizeof(DuLinkNode));
        p->data=a[i];
        p->next=L->next;   //更新插入结点的后继指针域
        p->prior=L;   //更新插入结点的前驱指针域
        L->next=p;    //更新前驱结点的后继指针域
        if(p->next!=NULL)
        {
            p->next->prior=p; //更新后继结点的前驱指针域
        }
        
    }
}

2.双链表的前趋遍历和后继遍历


void print_next(DuLinkList DL,int length)  //双链表的后继遍历
{
    while(length--)
    {
        printf("%d->",DL->next->data);
        DL=DL->next;
    }
    printf("NULL\n");
}

void print_prior(DuLinkList DL,int length)  //双链表的前趋遍历
{
    while(DL->next!=NULL)
    {
        DL=DL->next;
    }
    while(length--)
    {
        printf("%d->",DL->data);
        DL=DL->prior;
    }
    printf("NULL\n");
}

3.实践双链表:请你设计一个算法，将带头双向链表中数据结点的原有顺序保存在每个结点的next域中，而prior域将所有结点按照其值从小到大的顺序链接起来

next储存原先顺序，prior储存排序顺序，反向使用单链表的插入排序

关于单链表的插入排序

struct ListNode* insertionSortList(struct ListNode* head) {
    if (head == NULL) return NULL;  // 检查链表是否为空
    
    struct ListNode* L = (struct ListNode*)malloc(sizeof(struct ListNode));
    L->next = head;
    
    struct ListNode* ordermove;             // ordermove起点是头结点
    struct ListNode* disordermove = head->next; // disordermove起点是第二个元素，因为第一个元素默认有序
    head->next = NULL;  // 断开链表，只保留第一个元素作为初始有序链表
    
    while (disordermove != NULL) {  // 当disordermove遍历完之后循环结束
        ordermove = L;  // 重置 ordermove 为哑结点 L
        
        // 寻找插入点
        while (ordermove->next != NULL && ordermove->next->val < disordermove->val) {
            ordermove = ordermove->next;
        }
        
        // 插入 disordermove 到 ordermove 之后
        struct ListNode* nextDisorder = disordermove->next;  // 记录下一个待排序结点
        disordermove->next = ordermove->next;
        ordermove->next = disordermove;
        
        // 移动到下一个待排序结点
        disordermove = nextDisorder;
    }
    
    struct ListNode* sortedHead = L->next;  // 排序后的链表头部
    free(L);  // 释放哑结点
    return sortedHead;
}

4.实践循环双链表:设以头结点得双向循环链表表示得线性表为L=(a1，a2,a3，…,an)。试写一时间复杂度为o(n)的算法，将L改造为L(a1,a3,an,a4,a2)

首先，创建一个带头结点的循环双链表（采用尾插法方便）

void creat_doublecycleLinklist(DuLinkList &DL, int a[8],int length) //双链表的建立
{
    //创建一个头结点
    DL=(DuLinkNode *)malloc(sizeof(DuLinkNode));
    DL->next=DL;
    DL->prior=DL;
    
    DuLinkNode * cur=DL;
    //添加结点
    for(int i=0;i<length;i++)
    {
        DuLinkNode * p;
        p=(DuLinkNode *)malloc(sizeof(DuLinkNode));
        p->data=a[i];
        p->next=DL;   //更新插入结点的后继指针域
        p->prior=cur;   //更新插入结点的前驱指针域
        cur->next=p;    //更新前驱结点的后继指针域
        DL->prior=p;   //头结点的前驱指针
        cur=p; //更新L指针
        
    }
}

本题思路:

思路:遍历一遍双向循环链表，将偶数列拿出来，采用头插法建立一个新的链，最后再拼接起来。

本题代码，千万别忘了双向循环链表该考虑的都要考虑到

给出测试版代码和简化版代码

测试版代码

void reverse_doublecycleLink(DuLinkList &DL)
{
    //设置一个偶数表头(循环双链表)
    DuLinkList el=NULL;
    el=(DuLinkNode*)malloc(sizeof(DuLinkNode));
    el->next=el;
    el->prior=el;
    
    
    // 遍历一遍循环双链表
    DuLinkNode *p=DL->next; //定义一个指针控制循环
    DuLinkNode *pre=DL; //定义一个指针控制循环
    int jiou=0; //奇偶开头
    while(p!=DL)  //循环一遍
    {
        DuLinkNode *last=p->next;
        if(jiou==0)jiou=1;
        else jiou=0;  //奇偶标志
        
        if(jiou==0)  //偶数操作，
        {
            //将当前偶数头插进入el表
            p->next=el->next;
            el->next->prior=p;
            el->next=p;
            p->prior=el;
            
            //在原表中删掉这个偶数结点，删除结点时前趋后继都要修改
            pre->next=last;
            last->prior=pre;
            p=last;  //pre此时不变
            
        }
        else
        {
            p=p->next;
            pre=pre->next;
        }
    }
    
    //检验一下，当前DL的打印
    p=DL->next;
    while(p!=DL)
    {
        printf("%d->",p->data);
        p=p->next;
    }
    printf("\n");
    
    //检验一下，当前el的打印
    p=el->next;
    while(p!=el)
    {
        printf("%d->",p->data);
        p=p->next;
    }
    printf("\n");
    
    //检验成功，进行合并操作，需要el的尾指针和pl的尾指针,因为是循环链表直接能拿到
//    DuLinkNode *tail_dl=DL;
//    DuLinkNode *tail_el=el;
//    while(tail_dl->next!=DL)
//    {
//        tail_dl=tail_dl->next;
//    }
//    while(tail_el->next!=el)
//    {
//        tail_el=tail_el->next;
//    }
//    printf("el的尾指针%d\n",el->prior->data);
    
    printf("连接前的DL某尾的后继是%d\n",DL->prior->next->data);
    DL->prior->next=el->next;
    printf("连接后的DL某尾的后继是%d\n",DL->prior->next->data);
    el->next->prior=DL->prior;  //屁股连好了
    
    el->prior->next=DL;
    DL->prior=el->prior;  //头也连接好了
    
   // 终极检测
    
    //检验一下，当前DL的打印
    p=DL->next;
    while(p!=DL)
    {
        printf("%d->",p->data);
        p=p->next;
    }
    printf("\n");
    
    
}

简化版代码

void reverse_doublecycleLink(DuLinkList &DL)
{
    //设置一个偶数表头(循环双链表)
    DuLinkList el=NULL;
    el=(DuLinkNode*)malloc(sizeof(DuLinkNode));
    el->next=el;
    el->prior=el;
    
    
    // 遍历一遍循环双链表
    DuLinkNode *p=DL->next; //定义一个指针控制循环
    DuLinkNode *pre=DL; //定义一个指针控制循环
    int jiou=0; //奇偶开头
    while(p!=DL)  //循环一遍
    {
        DuLinkNode *last=p->next;
        if(jiou==0)jiou=1;
        else jiou=0;  //奇偶标志
        
        if(jiou==0)  //偶数操作，
        {
            //将当前偶数头插进入el表
            p->next=el->next;
            el->next->prior=p;
            el->next=p;
            p->prior=el;
            
            //在原表中删掉这个偶数结点，删除结点时前趋后继都要修改
            pre->next=last;
            last->prior=pre;
            p=last;  //pre此时不变
            
        }
        else
        {
            p=p->next;
            pre=pre->next;
        }
    }
    
    DL->prior->next=el->next;
    el->next->prior=DL->prior;  //屁股连好了
    el->prior->next=DL;
    DL->prior=el->prior;  //头也连接好了
    
}

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

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

相关文章

如何使用 Higress 快速构建 AI 应用？

如何使用 Higress 快速构建 AI 应用？

随着 AI 时代到来&#xff0c;基于大模型的应用对网关提出了新的要求&#xff0c;例如在不同 LLM 提供商之间进行负载均衡、构建 AI 应用的可观测能力、基于 token 的限流保护与配额管理、AI 应用内容安全等等。Higress 基于企业内外的丰富场景沉淀了众多面向AI的功能&#xff…
阅读更多...
pip3 : 无法将“pip3”项识别为 cmdlet、函数、脚本文件或可运行程序的名称。

pip3 : 无法将“pip3”项识别为 cmdlet、函数、脚本文件或可运行程序的名称。

1.找到python安装目录底下的Scripts&#xff0c;复制该路径&#xff1a;你安装python的目录\Scripts 我本地的&#xff1a;D:\devSoftware\python-all\Python39\Scripts 2.将该路径配置到环境变量Path里面 我的电脑 - 右键属性 - 系统 - 环境变量 - 找到path点击编辑 - 新建&a…
阅读更多...
家用超声波清洗机哪个品牌好用？实测解析四大高口碑超声波清洗机机型

家用超声波清洗机哪个品牌好用？实测解析四大高口碑超声波清洗机机型

提到超声波清洗机&#xff0c;很多人可能首先想到的是眼镜店或首饰店里的商用清洗设备。它们虽然功能强大&#xff0c;但价格较高且体积较大&#xff0c;并不适合家用。不过&#xff0c;现在有了一个更方便的选择&#xff1a;小型超声波清洗机。它们体积小巧&#xff0c;价格也…
阅读更多...
9.cmake(string)

9.cmake(string)

目录 1. 基本用法 2. string对于json的操作 3.代码段 1. 基本用法 以下通过截取字符串"begin test cmake string end "中的子串"test cmake string"来串联string中的部分用法&#xff0c;其中包括了FIND&#xff0c;LENGTH&#xff0c;SUBSTRING&#x…
阅读更多...
linux搭建ceph集群

linux搭建ceph集群

linux三节点搭建ceph集群 主机IP主机名称172.26.50.75node1172.26.50.112node2172.26.50.228node3 ceph-mon&#xff0c;ceph-mgr&#xff0c;ceph-mds都搭建在node1上&#xff0c;node2和node3上搭建ceph-osd&#xff0c;每个机器1个osd Ceph是一个分布式的存储系统&#x…
阅读更多...
选择排序（直接选择排序和堆排序）

选择排序（直接选择排序和堆排序）

一、直接选择排序 1.基本思想 每一次从待排序的数据元素中选出最小&#xff08;或最大&#xff09;的一个元素&#xff0c;存放在序列的起始位置&#xff0c;直到全部待排序的数据元素排完。 2.动图展示 3.思路讲解 ①在元素集合array[i]—array[n-1]中选择关键码最大&…
阅读更多...
个人博客系统-自动化测试

个人博客系统-自动化测试

1、项目背景 1.1技术背景 1&#xff09;个人博客系统主要是通过前端&#xff08;HTMLcssjs&#xff09;后端&#xff08;SpringBoot&#xff09;实现的一个博客的基本功能。前端通过jQuery的方式向后端请求数据。后端通过MyBatis从数据库中查询数据响应给前端。 2&#xff0…
阅读更多...
天通报警呼叫柱助力宜宾——破汛期河心洲岛通信困境，守护人民群众生命安全

天通报警呼叫柱助力宜宾——破汛期河心洲岛通信困境，守护人民群众生命安全

随着主汛期的到来&#xff0c;我国多地遭遇频繁降雨&#xff0c;强降雨或连绵不断的降雨&#xff0c;极易引发山洪、滑坡、泥石流等次生灾害。8月18日23时至20日10时&#xff0c;辽宁省西部地区出现暴雨到大暴雨&#xff0c;葫芦岛市部分乡镇出现特大暴雨。受到强降雨影响&…
阅读更多...
Qt-QWidget的windowIcon属性(14)

Qt-QWidget的windowIcon属性(14)

目录 描述 相关API 使用 并不需要在堆上创建 不要带中文路径 运行观察 不要使用绝对路径 描述 这个其实就是你打开窗口的左上角那个图标&#xff0c;这个就是用来设置那个的 相关API 使用 创建一个新的项目&#xff0c;如下&#xff0c;添加一个设置图片的代码 并不需…
阅读更多...
uboot中 fastboot udp 协议分析

uboot中 fastboot udp 协议分析

注&#xff1a; 1. 本文所分析的fastboot源码不是android下的源码&#xff0c;而是恩智浦芯片厂商在IMX6UL芯片的uboot源码中自己实现的源码&#xff0c;二者不同&#xff0c;请读者注意区分。一些图片是网上找到的&#xff0c;出处不好注明&#xff0c;请见谅。 2. 分析fastbo…
阅读更多...
VM——轮廓/快速匹配中的多模版匹配

VM——轮廓/快速匹配中的多模版匹配

1、轮廓或者快速匹配中支持建立多个模型&#xff0c;按照从上而下的顺序进行匹配&#xff0c;匹配上了即停止后续模版的匹配。 2、如果要多个模版都参与匹配&#xff0c;则需要打开“全部搜索模式”。 3、延拓阈值 “延拓阈值”&#xff0c;看参数名字不知所云&#xff0c;文档…
阅读更多...
CR-NeRF 代码eval.py解析

CR-NeRF 代码eval.py解析

这段代码是一个用于CR-NeRF&#xff08;Neural Radiance Fields&#xff09;模型的推理脚本。它主要用于生成和保存渲染的图像&#xff0c;并计算图像质量的评价指标&#xff08;如PSNR和SSIM&#xff09;。以下是对这段代码的详细解析&#xff1a; &#xff08;1&#xff09;…
阅读更多...
【亚马逊云科技】有手就能做到的Amazon Lightsail快速建站

【亚马逊云科技】有手就能做到的Amazon Lightsail快速建站

文章目录 前言一、为什么选择Amazon Lightsail二、创建账号与登录注册亚马逊账号登录控制台 三、创建Amazon Lightsail进入控制台创建实例实例配置查看实例查看网站定制页面 总结 前言 不论是个人名片还是官方网站都离不开网站建设工作。计算机技术经历漫长的发展&#xff0c;…
阅读更多...
2024年如何将低质量视频变成高质量视频

2024年如何将低质量视频变成高质量视频

创建低质量的视频对您没有好处&#xff0c;尤其是当您打算将这些视频上传到社交媒体帐户时。观众不喜欢观看模糊和低质量的视频&#xff0c;而这个东西没有意义&#xff0c;不会为你的内容增加价值。 那么&#xff0c;您应该如何确保您的社交媒体观众喜欢您的视频内容呢&#x…
阅读更多...
企业内部知识库意义何在？怎么搭建？

企业内部知识库意义何在？怎么搭建？

引言 在知识经济时代&#xff0c;企业竞争力的核心日益转向知识的管理与应用能力。随着企业规模的扩大和业务复杂性的增加&#xff0c;如何高效地收集、整理、存储并分享内部知识&#xff0c;成为了企业持续发展和创新的关键。企业内部知识库应运而生&#xff0c;它不仅帮助企…
阅读更多...
自定义注解+拦截器实现,对部分敏感字段的加解密

自定义注解+拦截器实现,对部分敏感字段的加解密

上一篇,我用的自定义注解AOP的方式,实现敏感字段的加解密,这一篇换个方案,这个方案相比一个方案,节省了一部分的性能开销 第一步:新建自定义注解 /*** 敏感信息类注解*/ Inherited Target({ElementType.TYPE}) Retention(RetentionPolicy.RUNTIME) public interface EnableSe…
阅读更多...
tomcat session共享

tomcat session共享

1. 日志监控工具 安装 tar xf goaccess-1.4.tar.gz cd goaccess-1.4/ yum install GeoIP-devel-1.5.0-13.el7.x86_64.rpm yum install -y ncurses-devel.x86_64 ./configure --enable-utf8 --enable-geoiplegacy make make install2. 使用 goaccess /usr/local/nginx/logs/a…
阅读更多...
java多线程（六）关键字Volatile可见性、有序性以及单个变量的原子性

java多线程（六）关键字Volatile可见性、有序性以及单个变量的原子性

volatile关键字 作用 volatile 是 Java 虚拟机提供的轻量级的同步机制&#xff0c;主要用来确保变量被线程安全地读取和写入。 当一个变量定义为 volatile 后&#xff0c;它具备以下特性&#xff1a; 可见性&#xff1a;确保不同线程对这个变量操作的可见性&#xff0c;即一…
阅读更多...
自存实践本地访问 nginx放前端打包好的项目

自存实践本地访问 nginx放前端打包好的项目

nginx 部署前端项目_哔哩哔哩_bilibili 将打包好的dits文件放到 配置nginx.conf文件的location 启动命令 start nginx.exe 输入localhost即可访问打包好的项目 nginx的特点 1.静态资源 2.转发 设置代理转发请求 关闭nginx .\nginx.exe -s quit
阅读更多...
Kubernetes-Pod调度基础

Kubernetes-Pod调度基础

一.复制控制器&#xff08;ReplicationController&#xff0c;RC&#xff09; RC用来确保Pod副本数达到预期值&#xff0c;这样可以确保一个或多个同类Pod总是可用的。可以通过扩缩来增加或减少pod。 &#xff08;1&#xff09;示例&#xff1a; vim replicationcontroller-ng…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023