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

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

2024-11-04 9
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
视觉智能开放平台，视频资源包5000点
视觉智能开放平台，图像资源包5000点
视觉智能开放平台，分割抠图1万点
简介： 数据结构王道第2.3章节之线性表精题汇总一

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

你的三连是我最大的动力

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

专栏跑道一

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

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章节之线性表精题汇总一

（10）题目:编辑

解题思路：

实现代码：

（11）题目：

解题思路：

（12）题目：

解题思路：

实现代码：

（13）题目：编辑

解题思路：

实现代码：

（14）题目：编辑

解题思路：

实现代码：

（15）题目：编辑

解题思路：

实现代码：

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

（10）题目: image.gif

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

解题思路：

1>定义位置变量,用于指示节点序号
2>然后定义两个尾指针，分别判断节点序号奇偶
3>使用尾插法进行插入

image.gif

实现代码：

#include <iostream>
using namespace std;
// 定义链表节点结构
typedef struct LNode
{
    int data;            // 节点数据
    struct LNode *next; // 指向下一个节点的指针
} LNode, *LinkList; // LinkList是指向LNode的指针类型
// 头插法
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;         // 将新节点链接到当前链表的最后
        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 BreakList(LinkList &LA, LinkList &LB)
{
    int i = 1; // 计数器
    LNode *p, *ra, *rb; // p指向原链表，ra和rb分别指向新链表的尾部
    p = LA->next; // 从LA的第一个节点开始
    ra = LA; // ra初始化为LA
    rb = LB; // rb初始化为LB
    ra->next = NULL; // 初始化LA的next为NULL
    rb->next = NULL; // 初始化LB的next为NULL
    while (p) // 遍历原链表
    {
        if (i % 2 == 1) // 如果是奇数节点
        {
            ra->next = p; // 将节点p链接到LA
            ra = p; // 更新ra为当前节点
        }
        else // 如果是偶数节点
        {
            rb->next = p; // 将节点p链接到LB
            rb = p; // 更新rb为当前节点
        }
        p = p->next; // 移动到下一个节点
        i++; // 计数器加1
    }
    ra->next = NULL; // 将LA的最后一个节点的next指针置为NULL
    rb->next = NULL; // 将LB的最后一个节点的next指针置为NULL
}
int main()
{
    LinkList LA = new LNode; // 创建链表A的头节点
    LinkList LB = new LNode; // 创建链表B的头节点
    TailInsert(LA); // 通过尾插法输入链表A的数据
    BreakList(LA, LB); // 将链表A分为链表LA和LB
    Print(LA); // 输出链表A的内容
    Print(LB); // 输出链表B的内容
}

image.gif

（11）题目：

设 C= {a，by，a2，b2…，amb}为线性表，采用带头结点的 hc 单链表存放，设计一个就地算法，将其拆分为两个线性表，使得A={a,a2, ,a}, B={bm…,b2,b}.设C={a1,b1,a2,b2}为线性表，采用带头节点的hc单链表Q存放，设计一个就地算法，将其拆分为两个线性表,使得A={a1,a2,an), B={bn,b2,b1}。

解题思路：

>问题的关键就是采用何种方式构建链表
>A采用尾插保持原顺序
>B采用前插法将其逆序

image.gif

 实现代码：

#include <iostream>
using namespace std;
// 定义链表节点结构
typedef struct LNode
{
    int data;            // 节点数据
    struct LNode *next; // 指向下一个节点的指针
} LNode, *LinkList; // LinkList是指向LNode的指针类型
// 头插法
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;         // 将新节点链接到当前链表的最后
        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 BreakList(LinkList &LA, LinkList &LB)
{
    LNode *p, *q, *ra; // p为工作指针，q保存后继指针，ra为LA的尾指针
    LB->next = NULL;   // 将LB链表置空
    p = LA->next; // 从LA的第一个节点开始
    ra = LA; // 初始化LA的尾指针
    while (p) // 遍历原链表
    {
        // 将当前节点p插入到LA
        ra->next = p;
        ra = p; // 更新ra为当前节点
        p = p->next; // 移动到下一个节点
        // 如果p不为空，继续将其前插到LB
        if (p)
        {
            q = p->next; // 保存p的后继，防止断链
            p->next = LB->next; // 将p插入到LB的头部
            LB->next = p; // 更新LB的头指针
            p = q; // 移动到下一个节点
        }
    }
    ra->next = NULL; // 将LA的尾节点的next指针置为NULL
}
int main()
{
    LinkList LA = new LNode; // 创建链表A的头节点
    LinkList LB = new LNode; // 创建链表B的头节点
    TailInsert(LA); // 通过尾插法输入链表A的数据
    BreakList(LA, LB); // 将链表A分为链表LA和LB
    Print(LA); // 输出链表A的内容
    Print(LB); // 输出链表B的内容
}

image.gif

（12）题目：

在一个递增有序的线性表中,有数值相同的元素存在。若存储方式为单链表,设计算法去掉数值相同的元素，使表中不再有重复的元素，例如(7, 10, 10,21,30,42,42,42,51,70)将变为(7,10,21, 30,42, 51,70).

解题思路：

>定义工作结点、待删除结点前驱
>如果发现某一结点值等于后继结点的值，将其删除

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 Duplicate(LinkList &L)
{
    LNode *p, *pre; // p用于遍历链表，pre用于记录前驱节点
    p = L->next; // p指向第一个实际数据节点
    pre = L;     // pre初始化为头节点
    while (p) // 遍历链表
    {
        // 检查当前节点和下一个节点是否值相同
        if (p->next && p->data == p->next->data)
        {
            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); // 使用尾插法插入节点
    Duplicate(L); // 删除重复元素
    Print(L); // 打印链表
}

image.gif

（13）题目： image.gif

假设有两个按元素值递增次序排列的线性表,均以单链表形式存储。请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来两个单链表的结点存放归并后的单链表.

解题思路：

>归并排序

image.gif

实现代码：

#include <iostream>
using namespace std;
// 定义链表节点结构
typedef struct LNode
{
    int data;            // 节点数据
    struct LNode *next; // 指向下一个节点的指针
} LNode, *LinkList; // LinkList 是指向 LNode 的指针类型
// 头插法
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;         // 将新节点链接到当前链表的最后
        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; // 输出换行
}
// 找到两个链表的公共节点并将其插入到链表 LC
void PublicNode(LinkList &LA, LinkList &LB, LinkList &LC)
{
    LNode *pa, *pb, *r; // 定义两个链表的工作节点和尾插指针
    pa = LA->next; // pa 初始化为链表 A 的第一个节点
    pb = LB->next; // pb 初始化为链表 B 的第一个节点
    r = LC; // r 指向链表 C 的头节点
    while (pa && pb) // 遍历两个链表
    {
        // 小节点的链表向后移
        if (pa->data < pb->data) // 如果 pa 指向的节点数据小于 pb
        {
            pa = pa->next; // pa 向后移动
        }
        else if (pa->data > pb->data) // 如果 pa 指向的节点数据大于 pb
        {
            pb = pb->next; // pb 向后移动
        }
        // 新建节点插入到 LC 尾部
        else // 如果 pa 和 pb 数据相等，即为公共节点
        {
            LNode *s = new LNode; // 创建新节点
            s->data = pa->data;   // 设置新节点的数据为公共节点的数据
            r->next = s;          // 将新节点插入到 LC 的尾部
            r = s;                // 更新 r 为新节点
            pa = pa->next;        // 移动到下一个节点
            pb = pb->next;        // 移动到下一个节点
        }
    }
    r->next = NULL; // 最后将 LC 的尾节点的 next 指针设为 NULL
}
int main()
{
    LinkList LA = new LNode; // 创建链表 A 的头节点
    LinkList LB = new LNode; // 创建链表 B 的头节点
    LinkList LC = new LNode; // 创建链表 C 的头节点
    TailInsert(LA); // 通过尾插法输入链表 A 的数据
    TailInsert(LB); // 通过尾插法输入链表 B 的数据
    PublicNode(LA, LB, LC); // 找到公共节点并插入到链表 C
    Print(LC); // 输出链表 C
}

image.gif

（14）题目： image.gif

设 A 和 B 是两个单链表（带头结点），其中元素递增有序。设计一个算法从 A 和 B 中的公共元素产生单链表 C，要求不破坏 A、B 的结点。

解题思路：

>类似于归并排序
>将相等结点插入LC

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; // 输出换行
}
// 找到两个链表的公共节点并存入LC
void PublicNode(LinkList &LA, LinkList &LB, LinkList &LC)
{
    LNode *pa, *pb, *r; // 定义两个链表的工作节点和尾插指针
    pa = LA->next; // pa指向链表LA的第一个数据节点
    pb = LB->next; // pb指向链表LB的第一个数据节点
    r = LC;        // r指向链表LC的头节点
    while (pa && pb) // 当两个链表都有节点时
    {
        // 比较当前节点的值
        if (pa->data < pb->data) // 如果LA的当前节点小于LB的当前节点
        {
            pa = pa->next; // LA向后移动
        }
        else if (pa->data > pb->data) // 如果LA的当前节点大于LB的当前节点
        {
            pb = pb->next; // LB向后移动
        }
        // 如果当前节点相等，说明找到公共节点
        else
        {
            LNode *s = new LNode; // 创建新节点
            s->data = pa->data;   // 将公共节点的值赋给新节点
            r->next = s;          // 将新节点插入到LC的尾部
            r = s;                // 更新尾指针r，指向新节点
            pa = pa->next;       // LA和LB都向后移动
            pb = pb->next;
        }
    }
    r->next = NULL; // 最后设置LC的尾指针的next为NULL
}
int main()
{
    LinkList LA = new LNode; // 创建链表LA的头节点
    LinkList LB = new LNode; // 创建链表LB的头节点
    LinkList LC = new LNode; // 创建链表LC的头节点
    TailInsert(LA); // 使用尾插法插入LA的节点
    TailInsert(LB); // 使用尾插法插入LB的节点
    PublicNode(LA, LB, LC); // 找到LA和LB的公共节点并存入LC
    Print(LC); // 打印链表LC
}

image.gif

（15）题目： image.gif

已知两个链表A和B分别表示两个集合,其元素递增排列。编制函数,求A与B的交集，并存放于 A 链表中

解题思路：

>类似归并排序
>将不等结点释放，相等结点进行尾插

image.gif

实现代码：

#include <iostream>
using namespace std;
// 定义链表节点结构
typedef struct LNode
{
    int data;            // 节点数据
    struct LNode *next; // 指向下一个节点的指针
} LNode, *LinkList; // LinkList 是指向 LNode 的指针类型
// 头插法
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;         // 将新节点链接到当前链表的最后
        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 PublicNode(LinkList &LA, LinkList &LB)
{
    LNode *pa, *pb, *r, *q; // 定义工作节点和尾插指针
    pa = LA->next; // pa 初始化为链表 A 的第一个节点
    pb = LB->next; // pb 初始化为链表 B 的第一个节点
    r = LA; // r 初始化为链表 A 的头节点
    while (pa && pb) // 遍历两个链表
    {
        // 如果 pa 数据小于 pb，则删除 pa，指针后移
        if (pa->data < pb->data)
        {
            q = pa; // 记录要删除的节点
            pa = pa->next; // pa 后移
            delete q; // 释放内存
        }
        // 如果 pa 数据大于 pb，则删除 pb，指针后移
        else if (pa->data > pb->data)
        {
            q = pb; // 记录要删除的节点
            pb = pb->next; // pb 后移
            delete q; // 释放内存
        }
        // 如果相等，将 pa 尾插，删除 pb
        else
        {
            r->next = pa; // 将 pa 插入到链表 A
            r = pa; // 更新尾插指针
            pa = pa->next; // pa 后移
            q = pb; // 记录要删除的节点
            pb = pb->next; // pb 后移
            delete q; // 释放内存
        }
    }
    // 将剩余所有节点全部释放
    while (pa) // 如果 pa 还有剩余节点
    {
        q = pa; // 记录要删除的节点
        pa = pa->next; // pa 后移
        delete q; // 释放内存
    }
    while (pb) // 如果 pb 还有剩余节点
    {
        q = pb; // 记录要删除的节点
        pb = pb->next; // pb 后移
        delete q; // 释放内存
    }
    r->next = NULL; // 将链表 A 的最后一个节点指向 NULL
    delete LB; // 释放链表 B 的头节点
}
int main()
{
    LinkList LA = new LNode; // 创建链表 A 的头节点
    LinkList LB = new LNode; // 创建链表 B 的头节点
    TailInsert(LA); // 通过尾插法输入链表 A 的数据
    TailInsert(LB); // 通过尾插法输入链表 B 的数据
    PublicNode(LA, LB); // 合并链表 A 和 B 的公共节点
    Print(LA); // 输出链表 A
}

image.gif

文章标签：
算法
Linux
安全
存储
NoSQL
肾透侧视攻城狮
目录
相关文章
弹性计算-百晓生
|
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
1849 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语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • 超全算法笔试 模拟题精解合集
  • 超全算法笔试-模拟题精解合集
  • 数据+算法定义新世界

    • 相关实验场景

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