AI 助理
备案控制台
开发者社区 视觉智能 文章 正文

2024重生之回溯数据结构与算法系列学习（8）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】

2024-11-04 10
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
视觉智能开放平台，视频资源包5000点
视觉智能开放平台，图像资源包5000点
视觉智能开放平台，分割抠图1万点
简介： 数据结构王道第2.3章之IKUN和I原达人之数据结构与算法系列学习x单双链表精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子；这都学不会；能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛？！！！

欢迎各位彦祖与热巴畅游本人专栏与博客

你的三连是我最大的动力

以下图片仅代表专栏特色 [点击箭头指向的专栏名即可闪现]

专栏跑道一

➡️网络空间安全——全栈前沿技术持续深入学习

image.gif

专栏跑道二

➡️ 24 Network Security -LJS

image.gif

image.gif

image.gif

专栏跑道三


➡️ MYSQL REDIS Advance operation

image.gif

专栏跑道四

➡️HCIP；H3C-SE;CCIP——LJS[华为、华三、思科高级网络]

image.gif

专栏跑道五

➡️RHCE-LJS[Linux高端骚操作实战篇]

image.png

专栏跑道六

➡️数据结构与算法[考研+实际工作应用+C程序设计]

image.gif

专栏跑道七

➡️RHCSA-LJS[Linux初级及进阶骚技能]

image.gif

image.gif

上节回顾






王道第2.3章节之线性表精题汇总四

（6）题目：试编写算法将带头节点的单链表Q就地逆置，所谓“就地”是指辅助空间复杂度为0(1)。

解题思路：

链表节点结构体 (LNode):
data 用于存储节点的数据。
next 是一个指针，用于指向下一个节点。
头插法 (HeadInsert):
通过不断读取输入，将新节点插入到链表的头部。
使用 L->next 来维护链表的结构。
尾插法 (TailInsert):
持续读取输入，将新节点追加到链表末尾。
r 用于跟踪当前尾部节点，更新尾部指针。
打印函数 (Print):
遍历链表，从头节点开始输出每个节点的数据。
反转链表 (fn):
将链表中的节点顺序反转。
使用三个指针：p 用于当前节点，r 用于暂存下一个节点，L->next 用于构建反转后的链表。
主函数 (main):
创建链表头节点，调用 TailInsert 进行数据插入，然后调用 fn 反转链表，最后输出反转后的链表。
  • image.gif

实现代码：

#include <iostream>
using namespace std;
// 定义链表节点结构体
typedef struct LNode
{
    int data;          // 节点数据
    struct LNode *next; // 指向下一个节点的指针
} LNode, *LinkList;
// 头插法
void HeadInsert(LinkList &L)
{
    int val = 0; // 存储输入的值
    while (cin >> val) // 持续接受输入
    {
        LNode *s = new LNode; // 创建新的节点
        s->data = val;        // 将输入值赋给节点数据
        s->next = L->next;   // 新节点指向当前链表的第一个节点
        L->next = s;         // 更新头指针，指向新节点
        // 判断是否为输入结束
        if (cin.get() == '\n')
        {
            break; // 如果遇到换行，结束输入
        }
    }
}
// 尾插法
void TailInsert(LinkList &L)
{
    int val = 0; // 存储输入的值
    LNode *r = L; // r指向尾部节点
    while (cin >> val) // 持续接受输入
    {
        LNode *s = new LNode; // 创建新的节点
        s->data = val;        // 将输入值赋给节点数据
        r->next = s;         // 尾节点的next指向新节点
        r = s;               // r更新为新节点
        r->next = NULL;      // 新节点的next指向NULL
        // 判断是否为输入结束
        if (cin.get() == '\n')
        {
            break; // 如果遇到换行，结束输入
        }
    }
}
// 遍历输出链表元素
void Print(LinkList L)
{
    LNode *p = L->next; // 从头节点的下一个节点开始遍历
    while (p)
    {
        cout << p->data << '\t'; // 输出节点数据
        p = p->next; // 移动到下一个节点
    }
    cout << endl; // 输出换行
}
// 反转链表
void fn(LinkList &L)
{
    LNode *p, *r;
    p = L->next; // 从链表的第一个节点开始
    L->next = NULL; // 清空链表
    // 反转链表
    while (p)
    {
        r = p->next; // 暂存当前节点的下一个节点
        p->next = L->next; // 当前节点的next指向新的头节点
        L->next = p; // 更新链表头，指向当前节点
        p = r; // 移动到下一个节点
    }
}
int main()
{
    LinkList L = new LNode; // 创建链表头节点
    TailInsert(L); // 调用尾插法插入数据
    fn(L); // 反转链表
    Print(L); // 打印链表
}
  • image.gif

（7）题目：设在一个带表头节点的 单链表Q中所有元素节点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值(作为函数参数给出)之间的元素的元素(若存在) 。

解题思路：

>定义工作指针p、前驱指针q
>遍历链表删除节点
链表节点结构体 (LNode):
data：用于存储节点的数据。
next：指向下一个节点的指针。
头插法 (HeadInsert):
通过不断读取输入，将新节点插入到链表的头部。
使用 L->next 来维护链表的结构。
尾插法 (TailInsert):
持续读取输入，将新节点追加到链表末尾。
r 用于跟踪当前尾部节点，更新尾部指针。
打印函数 (Print):
遍历链表，从头节点开始输出每个节点的数据。
删除指定范围内的节点 (DelValue):
该函数用于删除链表中数据值在 left 和 right 之间的所有节点。
使用两个指针 p 和 pre 来维护当前节点和前驱节点，判断并删除符合条件的节点。
主函数 (main):
  • image.gif

实现代码： 

#include <iostream>
using namespace std;
// 定义链表节点结构体
typedef struct LNode
{
    int data;          // 节点数据
    struct LNode *next; // 指向下一个节点的指针
} LNode, *LinkList;
// 头插法函数
void HeadInsert(LinkList &L)
{
    int val = 0; // 存储输入的值
    while (cin >> val) // 持续接受输入
    {
        LNode *s = new LNode; // 创建新的节点
        s->data = val;        // 将输入值赋给节点数据
        s->next = L->next;   // 新节点指向当前链表的第一个节点
        L->next = s;         // 更新头指针，指向新节点
        // 判断是否为输入结束
        if (cin.get() == '\n')
        {
            break; // 如果遇到换行，结束输入
        }
    }
}
// 尾插法函数
void TailInsert(LinkList &L)
{
    int val = 0; // 存储输入的值
    LNode *r = L; // r指向尾部节点
    while (cin >> val) // 持续接受输入
    {
        LNode *s = new LNode; // 创建新的节点
        s->data = val;        // 将输入值赋给节点数据
        r->next = s;         // 尾节点的next指向新节点
        r = s;               // r更新为新节点
        r->next = NULL;      // 新节点的next指向NULL
        // 判断是否为输入结束
        if (cin.get() == '\n')
        {
            break; // 如果遇到换行，结束输入
        }
    }
}
// 遍历输出链表元素
void Print(LinkList L)
{
    LNode *p = L->next; // 从头节点的下一个节点开始遍历
    while (p)
    {
        cout << p->data << '\t'; // 输出节点数据
        p = p->next; // 移动到下一个节点
    }
    cout << endl; // 输出换行
}
// 删除指定范围内的节点
void DelValue(LinkList &L, int left, int right)
{
    LNode *p, *pre; // p用于当前节点，pre用于前驱节点
    p = L->next; // 从链表的第一个节点开始
    pre = L; // pre初始化为头节点
    while (p) // 当当前节点不为空时循环
    {
        // 检查节点数据是否在指定范围内
        if (p->data > left && p->data < right)
        {
            LNode *q = p; // 暂存待删除节点
            p = p->next; // 移动到下一个节点
            pre->next = p; // 前驱节点的next指向当前节点的下一个节点
            delete q; // 删除旧节点，释放内存
        }
        else // 若不在指定范围内
        {
            pre = p; // 更新前驱节点
            p = p->next; // 移动到下一个节点
        }
    }
}
int main()
{
    LinkList L = new LNode; // 创建链表头节点
    TailInsert(L); // 调用尾插法插入数据
    DelValue(L, 3, 5); // 删除数据在3和5之间的节点
    Print(L); // 打印链表
}
  • image.gif

（8）题目：给定两个单链表Q，编写算法找出两个链表的公共结点。

解题思路：

>公共结点之后的所有结点地址均一致
>所以只需要比较结点即可
>但是需要二者从同一倒数长度开始
>所以长的链表需要先向后偏移链表长度之差
链表结构: 使用 LNode 结构体定义链表节点，包括数据和指向下一个节点的指针。
链表操作:
HeadInsert: 使用头插法插入数据。
TailInsert: 使用尾插法插入数据。
Print: 输出链表中所有节点的数据。
PublicNode: 查找两个链表的公共节点，并输出该节点的数据。
主函数: 创建两个链表，构建公共节点，并调用 PublicNode 函数查找和打印公共节点的数据。

实现代码：

#include <iostream>
using namespace std;
// 定义链表节点结构体
typedef struct LNode
{
    int data;          // 节点数据
    struct LNode *next; // 指向下一个节点的指针
} LNode, *LinkList;
// 头插法创建链表
void HeadInsert(LinkList &L)
{
    int val = 0;
    // 从输入中读取值，直到遇到换行符
    while (cin >> val)
    {
        LNode *s = new LNode; // 创建新节点
        s->data = val;       // 设置节点数据
        s->next = L->next;   // 新节点指向当前链表的第一个节点
        L->next = s;         // 更新头节点的指针指向新节点
        // 检测是否为换行符
        if (cin.get() == '\n')
        {
            break;
        }
    }
}
// 尾插法创建链表
void TailInsert(LinkList &L)
{
    int val = 0;
    LNode *r = L; // r指向当前链表的最后一个节点
    while (cin >> val)
    {
        LNode *s = new LNode; // 创建新节点
        s->data = val;        // 设置节点数据
        r->next = s;          // 将当前节点的next指向新节点
        r = s;                // 更新r指向新节点
        r->next = NULL;       // 新节点的next为NULL
        // 检测是否为换行符
        if (cin.get() == '\n')
        {
            break;
        }
    }
}
// 遍历输出链表元素
void Print(LinkList L)
{
    LNode *p = L->next; // p指向链表的第一个节点
    while (p)
    {
        cout << p->data << '\t'; // 输出节点数据
        p = p->next;             // 移动到下一个节点
    }
    cout << endl;
}
// 查找两个链表的公共节点
void PublicNode(LinkList &LA, LinkList &LB)
{
    int lena = 0, lenb = 0;
    LNode *p = LA->next;
    
    // 计算链表A的长度
    while (p)
    {
        lena++;
        p = p->next;
    }
    p = LB->next;
    // 计算链表B的长度
    while (p)
    {
        lenb++;
        p = p->next;
    }
    LNode *longList, *shortList;
    int dist = 0;
    // 确定较长和较短的链表
    if (lena > lenb)
    {
        longList = LA->next; // 链表A较长
        shortList = LB->next; // 链表B较短
        dist = lena - lenb;   // 计算长度差
    }
    else
    {
        longList = LB->next; // 链表B较长
        shortList = LA->next; // 链表A较短
        dist = lenb - lena;   // 计算长度差
    }
    // 移动较长链表的指针，使其与较短链表对齐
    while (dist--)
    {
        longList = longList->next;
    }
    // 同时遍历两个链表，寻找公共节点
    while (longList != NULL)
    {
        if (longList == shortList) // 找到公共节点
        {
            cout << longList->data; // 输出公共节点数据
            return;
        }
        else
        {
            longList = longList->next; // 移动到下一个节点
            shortList = shortList->next;
        }
    }
}
int main()
{
    LNode *p1 = new LNode; // 创建链表A的头结点
    LNode *q1 = new LNode; // 创建链表B的头结点
    LNode *q2 = new LNode; // 链表B的节点
    LNode *q3 = new LNode; // 链表B的节点
    // 公共结点
    LNode *m1 = new LNode;
    m1->data = 99999; // 公共节点的数据
    LNode *m2 = new LNode; // 公共节点的下一个节点
    m1->next = m2; // 设置公共节点的下一个节点
    m2->next = NULL; // 公共节点的下一节点指向NULL
    p1->next = m1; // 链表A连接公共节点
    // 构建链表B
    q1->next = q2; // q1指向q2
    q2->next = q3; // q2指向q3
    q3->next = m1; // q3指向公共节点m1
    // 查找并输出公共节点
    PublicNode(p1, q1);
}
  • image.gif

（9）题目：给定一个带表头结点的单链表，设head为头指针，结点结构为（data，next），data为整型元素，next为指针，试写出算法：按递增次序输出单链表中各节点的数据元素，并释放结点所占的存储空间(要求:不允许使用数组作为辅助空间)。

解题思路：


>遍历链表找到最小值将其输入
>然后将其删除，重复该过程
>直到表为空
链表结构: 使用 LNode 结构体定义链表节点，包括数据和指向下一个节点的指针。
链表操作:
HeadInsert: 头插法创建链表（未在 main 中调用）。
TailInsert: 尾插法创建链表，从标准输入读取整数，直到遇到换行符。
Print: 遍历链表，输出所有节点的数据（未在 main 中调用）。
PrintValue: 遍历链表，找到并输出每次遍历中的最小值，并删除该节点。
主函数: 创建一个链表，调用 TailInsert 函数添加数据，然后调用 PrintValue 函数输出并删除链表中的最小值。

实现代码：

#include <iostream>
using namespace std;
// 定义链表节点结构体
typedef struct LNode
{
    int data;          // 节点数据
    struct LNode *next; // 指向下一个节点的指针
} LNode, *LinkList;
// 头插法创建链表
void HeadInsert(LinkList &L)
{
    int val = 0;
    // 从输入中读取值，直到遇到换行符
    while (cin >> val)
    {
        LNode *s = new LNode; // 创建新节点
        s->data = val;       // 设置节点数据
        s->next = L->next;   // 新节点指向当前链表的第一个节点
        L->next = s;         // 更新头节点的指针指向新节点
        // 检测是否为换行符
        if (cin.get() == '\n')
        {
            break;
        }
    }
}
// 尾插法创建链表
void TailInsert(LinkList &L)
{
    int val = 0;
    LNode *r = L; // r指向当前链表的最后一个节点
    while (cin >> val)
    {
        LNode *s = new LNode; // 创建新节点
        s->data = val;        // 设置节点数据
        r->next = s;          // 将当前节点的next指向新节点
        r = s;                // 更新r指向新节点
        r->next = NULL;       // 新节点的next为NULL
        // 检测是否为换行符
        if (cin.get() == '\n')
        {
            break;
        }
    }
}
// 遍历输出链表元素
void Print(LinkList L)
{
    LNode *p = L->next; // p指向链表的第一个节点
    while (p)
    {
        cout << p->data << '\t'; // 输出节点数据
        p = p->next;             // 移动到下一个节点
    }
    cout << endl;
}
// 输出链表中的最小值并删除
void PrintValue(LinkList &L)
{
    LNode *p, *pre;
    LNode *minP, *minPre;
    // 当链表还有节点时循环
    while (L->next)
    {
        p = L->next; // 从第一个节点开始
        pre = L;     // pre指向当前节点的前驱
        minP = L->next; // 初始最小节点为第一个节点
        minPre = L;     // 最小节点的前驱为头节点
        // 遍历链表查找最小值节点
        while (p)
        {
            if (p->data < minP->data) // 找到更小的值
            {
                minP = p;        // 更新最小节点
                minPre = pre;    // 更新最小节点前驱
            }
            pre = p; // 移动前驱指针
            p = p->next; // 移动当前指针
        }
        // 输出最小值
        cout << minP->data << '\t';
        
        // 删除最小值节点
        LNode *q = minP;          // 临时保存最小节点
        minPre->next = minP->next; // 更新前驱节点的next指针
        delete q;                // 删除最小节点
    }
}
int main()
{
    LinkList L = new LNode; // 创建链表的头结点
    TailInsert(L);          // 调用尾插法插入数据
    PrintValue(L);         // 打印链表中的最小值并删除
}
  • image.gif

（10）题目：将一个带头节点的单链表QA分解为两个带头节点的单链表A和B,使得A表中含有原表中序号为奇数的元素，而B表中含有原表中序号为偶数的元素，且保持其相对顺序不变。


解题思路：

>定义位置变量，用于指示节点序号
>然后定义两个尾指针，分别判断节点序号奇偶
>使用尾插法进行插入
链表结构: 使用 LNode 结构体定义链表节点，包括数据和指向下一个节点的指针。
链表操作:
HeadInsert: 头插法创建链表（未在 main 中调用）。
TailInsert: 尾插法创建链表，从标准输入读取整数，直到遇到换行符。
Print: 遍历链表，输出所有节点的数据。
BreakList: 将原链表中的节点分成两个链表，奇数位置的节点放入链表 LA，偶数位置的节点放入链表 LB。
主函数:
创建两个链表 LA 和 LB 的头节点。
调用 TailInsert 函数添加数据到链表 LA。
调用 BreakList 函数将链表 LA 分割成两个链表 LA 和 LB。
打印两个链表的内容。

实现代码：

#include <iostream>
using namespace std;
// 定义链表节点结构体
typedef struct LNode
{
    int data;               // 节点数据
    struct LNode *next;    // 指向下一个节点的指针
} LNode, *LinkList;
// 头插法创建链表
void HeadInsert(LinkList &L)
{
    int val = 0;
    while (cin >> val) // 从标准输入读取值
    {
        LNode *s = new LNode; // 创建新节点
        s->data = val;        // 设置节点数据
        s->next = L->next;    // 新节点指向当前链表的第一个节点
        L->next = s;          // 更新头节点的指针指向新节点
        // 检测是否为换行符
        if (cin.get() == '\n')
        {
            break; // 遇到换行符结束输入
        }
    }
}
// 尾插法创建链表
void TailInsert(LinkList &L)
{
    int val = 0;
    LNode *r = L; // r指向链表的最后一个节点
    while (cin >> val) // 从标准输入读取值
    {
        LNode *s = new LNode; // 创建新节点
        s->data = val;        // 设置节点数据
        r->next = s;          // 将当前节点的next指向新节点
        r = s;                // 更新r指向新节点
        r->next = NULL;       // 新节点的next指向NULL
        // 检测是否为换行符
        if (cin.get() == '\n')
        {
            break; // 遇到换行符结束输入
        }
    }
}
// 遍历输出链表元素
void Print(LinkList L)
{
    LNode *p = L->next; // p指向链表的第一个节点
    while (p) // 当p不为空时
    {
        cout << p->data << '\t'; // 输出节点数据
        p = p->next;             // 移动到下一个节点
    }
    cout << endl; // 输出换行
}
// 将链表分成两个链表，奇数节点进入LA，偶数节点进入LB
void BreakList(LinkList &LA, LinkList &LB)
{
    int i = 1; // 节点计数器
    LNode *p, *ra, *rb;
    p = LA->next; // 从LA的第一个节点开始
    ra = LA;      // ra指向LA链表的当前末尾
    rb = LB;      // rb指向LB链表的当前末尾
    ra->next = NULL; // 初始化LA的next为空
    rb->next = NULL; // 初始化LB的next为空
    // 遍历原链表
    while (p)
    {
        if (i % 2 == 1) // 如果是奇数位置的节点
        {
            ra->next = p; // 将当前节点链接到LA
            ra = p;       // 更新ra指向当前节点
        }
        else // 如果是偶数位置的节点
        {
            rb->next = p; // 将当前节点链接到LB
            rb = p;       // 更新rb指向当前节点
        }
        p = p->next; // 移动到下一个节点
        i++;         // 计数器加一
    }
    ra->next = NULL; // 结束LA链表
    rb->next = NULL; // 结束LB链表
}
int main()
{
    LinkList LA = new LNode; // 创建链表LA的头节点
    LinkList LB = new LNode; // 创建链表LB的头节点
    TailInsert(LA);          // 使用尾插法创建链表LA
    BreakList(LA, LB);      // 将链表LA分成两个链表LA和LB
    Print(LA);              // 打印链表LA
    Print(LB);              // 打印链表LB
}


文章标签：
算法
Linux
安全
搜索推荐
NoSQL
关键词：
回溯数据结构王道ikun丢脸
算法丢脸
算法王道考研
数据结构与算法王道
回溯数据结构与算法
肾透侧视攻城狮
目录
相关文章
弹性计算-百晓生
|
3天前
|
弹性计算 双11 开发者
阿里云ECS“99套餐”再升级！双11一站式满足全年算力需求
11月1日，阿里云弹性计算ECS双11活动全面开启，在延续火爆的云服务器“99套餐”外，CPU、GPU及容器等算力产品均迎来了全年最低价。同时，阿里云全新推出简捷版控制台ECS Lite及专属宝塔面板，大幅降低企业和开发者使用ECS云服务器门槛。
弹性计算-百晓生
87625 8
弹性计算-百晓生
|
21天前
|
存储 弹性计算 人工智能
阿里云弹性计算_通用计算专场精华概览 | 2024云栖大会回顾
阿里云弹性计算产品线、存储产品线产品负责人Alex Chen（陈起鲲）及团队内多位专家，和中国电子技术标准化研究院云计算标准负责人陈行、北京望石智慧科技有限公司首席架构师王晓满两位嘉宾，一同带来了题为《通用计算新品发布与行业实践》的专场Session。本次专场内容包括阿里云弹性计算全新发布的产品家族、阿里云第 9 代 ECS 企业级实例、CIPU 2.0技术解读、E-HPC+超算融合、倚天云原生算力解析等内容，并发布了国内首个云超算国家标准。
弹性计算-百晓生
101029 9
阿里云弹性计算_通用计算专场精华概览 | 2024云栖大会回顾
周周的奇妙编程
|
3天前
|
人工智能 弹性计算 文字识别
基于阿里云文档智能和RAG快速构建企业"第二大脑"
在数字化转型的背景下，企业面临海量文档管理的挑战。传统的文档管理方式效率低下，难以满足业务需求。阿里云推出的文档智能（Document Mind）与检索增强生成（RAG）技术，通过自动化解析和智能检索，极大地提升了文档管理的效率和信息利用的价值。本文介绍了如何利用阿里云的解决方案，快速构建企业专属的“第二大脑”，助力企业在竞争中占据优势。
周周的奇妙编程
4907 4
周周的奇妙编程
|
1天前
|
人工智能 自然语言处理 安全
创新不设限，灵码赋新能：通义灵码新功能深度评测
自从2023年通义灵码发布以来，这款基于阿里云通义大模型的AI编码助手迅速成为开发者心中的“明星产品”。它不仅为个人开发者提供强大支持，还帮助企业团队提升研发效率，推动软件开发行业的创新发展。本文将深入探讨通义灵码最新版本的三大新功能：@workspace、@terminal 和 #team docs，分享这些功能如何在实际工作中提高效率的具体案例。
周周的奇妙编程
2858 8
沃通WoTrus
|
7天前
|
负载均衡 算法 网络安全
阿里云WoSign SSL证书申请指南_沃通SSL技术文档
阿里云平台WoSign品牌SSL证书是由阿里云合作伙伴沃通CA提供，上线阿里云平台以来，成为阿里云平台热销的国产品牌证书产品，用户在阿里云平台https://www.aliyun.com/product/cas 可直接下单购买WoSign SSL证书，快捷部署到阿里云产品中。
沃通WoTrus
1850 6
阿里云WoSign SSL证书申请指南_沃通SSL技术文档
沃通WoTrus
|
10天前
|
Web App开发 算法 安全
什么是阿里云WoSign SSL证书？_沃通SSL技术文档
WoSign品牌SSL证书由阿里云平台SSL证书合作伙伴沃通CA提供，上线阿里云平台以来，成为阿里云平台热销的国产品牌证书产品。
沃通WoTrus
1789 2
石臻臻的杂货铺
|
19天前
|
编解码 Java 程序员
写代码还有专业的编程显示器？
写代码已经十个年头了, 一直都是习惯直接用一台Mac电脑写代码 偶尔接一个显示器, 但是可能因为公司配的显示器不怎么样, 还要接转接头 搞得桌面杂乱无章，分辨率也低，感觉屏幕还是Mac自带的看着舒服
石臻臻的杂货铺
3783 12
云大宝
|
26天前
|
存储 人工智能 缓存
AI助理直击要害，从繁复中提炼精华——使用CDN加速访问OSS存储的图片
本案例介绍如何利用AI助理快速实现OSS存储的图片接入CDN，以加速图片访问。通过AI助理提炼关键操作步骤，避免在复杂文档中寻找解决方案。主要步骤包括开通CDN、添加加速域名、配置CNAME等。实测显示，接入CDN后图片加载时间显著缩短，验证了加速效果。此方法大幅提高了操作效率，降低了学习成本。
云大宝
5386 15
探索云世界
|
13天前
|
人工智能 关系型数据库 Serverless
1024，致开发者们——希望和你一起用技术人独有的方式，庆祝你的主场
阿里云开发者社区推出“1024·云上见”程序员节专题活动，包括云上实操、开发者测评和征文三个分会场，提供14个实操活动、3个解决方案、3 个产品方案的测评及征文比赛，旨在帮助开发者提升技能、分享经验，共筑技术梦想。
探索云世界
1139 152
绿水长流*z
|
21天前
|
存储 缓存 关系型数据库
MySQL事务日志-Redo Log工作原理分析
事务的隔离性和原子性分别通过锁和事务日志实现，而持久性则依赖于事务日志中的`Redo Log`。在MySQL中，`Redo Log`确保已提交事务的数据能持久保存，即使系统崩溃也能通过重做日志恢复数据。其工作原理是记录数据在内存中的更改，待事务提交时写入磁盘。此外，`Redo Log`采用简单的物理日志格式和高效的顺序IO，确保快速提交。通过不同的落盘策略，可在性能和安全性之间做出权衡。
绿水长流*z
1585 14

视觉智能

热门文章

最新文章

  • 1
    【阿里云MVP Meetup 第四期】产业中的“图像识别”分享与探索，干货来袭！
  • 2
    【图像识别】白天鹅黑天鹅灰天鹅？卷积神经网络帮你识别
  • 3
    视觉智能开放平台【商品理解】【图像识别】【图像分割】上线新算法啦！
  • 4
    【图像算法】彩色图像分割专题七：基于分水岭的彩色分割
  • 5
    带你读《深度学习与图像识别：原理与实践》之一：机器视觉在行业中的应用
  • 6
    YOLOv8改进 | 主干网络 | 增加网络结构增强小目标检测能力【独家创新——附结构图】
  • 7
    ‘通义万相’使用体验——令人惊艳的AI绘画创作大模型
  • 8
    【OpenVI-图像超分实战篇】别用GAN做超分了，快来试试基于扩散模型的图像超分吧！
  • 9
    达摩院CVPR2023人脸重建论文HRN解读——REALY榜单冠军模型
  • 10
    极智AI | 一文看懂昇腾达芬奇架构计算单元
  • 1
    2024重生之回溯数据结构与算法系列学习之串（12）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丟脸好嘛？】
    12
  • 2
    2024重生之回溯数据结构与算法系列学习（11）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丟脸好嘛？】
    6
  • 3
    2024重生之回溯数据结构与算法系列学习之栈和队列精题汇总（10）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
    9
  • 4
    2024重生之回溯数据结构与算法系列学习之单双链表精题详解（9）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
    10
  • 5
    2024重生之回溯数据结构与算法系列学习（8）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
    10
  • 6
    2024重生之回溯数据结构与算法系列学习（7）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
    7
  • 7
    2024重生之回溯数据结构与算法系列学习之王道第2.3章节之线性表精题汇总二（5）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
    7
  • 8
    23
    6
  • 9
    2024重生之回溯数据结构与算法系列学习之单双链表精题（4）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
    9
  • 10
    2024重生之回溯数据结构与算法系列学习之单双链表【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
    6

    • 相关课程

    更多
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • 超全算法笔试 模拟题精解合集
  • 超全算法笔试-模拟题精解合集
  • 【云栖精选7月刊】抛开晦涩的算法、模型，让我们来谈谈互联网架构

    • 相关实验场景

    更多
  • 使用Swing算法实现商品推荐
  • RSA密码算法设计与实现
  • 欧拉图的构造性证明与算法实现
  • 推荐系统入门之使用ALS算法实现打分预测
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月