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

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

2024-11-04 254
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 数据结构王道第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
盛透侧视攻城狮
目录
相关文章
ClawdbotMoltbot
|
3月前
|
Linux API 数据安全/隐私保护
告别上下文污染！OpenClaw多Agent实战（阿里云+本地）+ 免费API配置+隔离技巧
2026年，OpenClaw的实战价值已从“单一智能体执行”升级为“多智能体协同”。很多用户在长期使用中发现，将写作、客服、自动化、资料整理等所有任务塞进一个Agent，会导致上下文串味、Token消耗激增、记忆污染等问题——简单的咨询要拖着海量无关历史对话，专业场景的回复混入日常聊天语气。
ClawdbotMoltbot
1594 8
流楚丶格念
|
XML JSON 数据处理
postman 中 body的form-data，x-www-form-urlencoded,raw,binary含义
postman 中 body的form-data，x-www-form-urlencoded,raw,binary含义
流楚丶格念
919 0
postman 中 body的form-data，x-www-form-urlencoded,raw,binary含义
nick6507384252
|
6月前
|
机器学习/深度学习 人工智能 决策智能
小模型驱动大智能：NVIDIA新研究实现2.5倍效率提升，成本直降70%
NVIDIA联合港大提出ToolOrchestra，用小模型动态编排工具链，通过强化学习优化推理路径，在保证智能水平的同时提升2.5倍效率、降低70%成本，实现“以小控大”的高效AI新范式。
nick6507384252
187 0
探索云世界
|
12月前
|
机器学习/深度学习 人工智能 城市大脑
大家之言｜人工智能发展趋势与基础设施建设之路
中国AI技术发展已从跟跑转向基建领跑，“十四五”期间算力规模年均增速达27%。杭州城市大脑升级AI智能体集群，重庆部署超大城市治理系统，宁夏作为“东数西算”枢纽持续突破算力规模。专家梅建平指出，人工智能虽为核心驱动力，但需警惕过度期望，理性看待其局限性。国家提出“三步走”战略与“一体两翼”规划，推动算力基础设施建设，如“东数西算”和全国一体化算力网，以优化资源调度并促进数字经济高质量发展。
探索云世界
492 0
游客u6vcprrm3r23y
|
缓存 前端开发 Android开发
鸿蒙5开发宝藏案例分享---在线短视频流畅切换
鸿蒙开发者联盟中的【最佳实践】分区藏着性能优化的“外挂级”方案！例如短视频秒切优化：通过专属视频渲染通道、预加载和动效抢跑，将起播时延压至230ms内。此外还有金融App防崩溃、折叠屏适配等硬核案例，带真实数据对比与避坑指南，代码直接可用。别卷了，官方已把“轮子工厂”开到你家门口！
游客u6vcprrm3r23y
251 0
阿里云大数据Al技术
|
机器学习/深度学习 人工智能 自然语言处理
阿里云人工智能平台 PAI 开源 EasyDistill 框架助力大语言模型轻松瘦身
本文介绍了阿里云人工智能平台 PAI 推出的开源工具包 EasyDistill。随着大语言模型的复杂性和规模增长，它们面临计算需求和训练成本的障碍。知识蒸馏旨在不显著降低性能的前提下，将大模型转化为更小、更高效的版本以降低训练和推理成本。EasyDistill 框架简化了知识蒸馏过程，其具备多种功能模块，包括数据合成、基础和进阶蒸馏训练。通过数据合成，丰富训练集的多样性；基础和进阶蒸馏训练则涵盖黑盒和白盒知识转移策略、强化学习及偏好优化，从而提升小模型的性能。
阿里云大数据Al技术
2449 7
颜淡慕潇
|
JSON Kubernetes 安全
【网络技术】什么是CNI
【网络技术】什么是CNI
颜淡慕潇
1724 0
爱专研的技术土狗
分享一些在 1688 上找一件代发商品的技巧
在1688上找一件代发商品需明确自身需求与定位，筛选可靠供应商，研究商品信息，利用精准搜索和平台推荐，关注活动，并与供应商充分沟通，确保合作顺畅。
爱专研的技术土狗
2315 0
杭州小哥哥
|
存储 关系型数据库 MySQL
MySQL系列： undo和redo工作原理
MySQL系列： undo和redo工作原理
杭州小哥哥
511 1
abcd552191868
|
编解码 索引 Windows
FFMPEG常用指令整理（未完结）
ffmpeg是通用的媒体转换器，可以将广泛的输入（包括实时的抓取和记录设备）-过滤和转换为我们想要的输出格式文件。
abcd552191868
481 0

视觉智能

热门文章

最新文章

  • 1
    基于深度学习的自然场景文字检测及端到端的OCR中文文字识别
  • 2
    OPENCV图像处理提高(一）图像增强
  • 3
    OpenCV+深度学习预训练模型，简单搞定图像识别 | 教程
  • 4
    图像文字识别(OCR)用什么算法小结
  • 5
    清华大学张长水教授：机器学习和图像识别（附视频、PPT下载）
  • 6
    【阿里云MVP Meetup 第四期】产业中的“图像识别”分享与探索，干货来袭！
  • 7
    阿里云智能图像识别服务发布
  • 8
    【OpenCV学习笔记 023】两种图像分割方法比较
  • 9
    Python黑科技：50行代码运用Python＋OpenCV实现人脸追踪+详细教程+快速入门+图像识别+人脸识别+大神讲解
  • 10
    阿里云达摩院资深算法专家浅谈：视觉生产技术探索及应用
  • 1
    一线互联 × Rokid AI眼镜：为什么它是工业4.0时代一线人员的标准装备？
    23
  • 2
    Rokid AI 眼镜远程协作应用"一线互联"开发实践：设备发现与 BLE 扫描
    32
  • 3
    "多路全景视频实时拼接融合"边缘计算网关几种拼接方式
    134
  • 4
    YOLO26如何涨点系列篇（NEU-DET缺陷检测） | CVPR2026 FAAFusion 解决Neck跨尺度方向冲突，实现涨点1.2%
    146
  • 5
    2472.一款图片批量提取工具：从文章到图库，一招搞定素材管理_创建自己的永久免费图床
    294
  • 6
    ECS GPU 上跑 vLLM：模型目录、镜像和 runtime 排查记录
    134
  • 7
    视觉大模型结合Agentic Workflow：侠客工坊重构移动端GUI自动化的技术实践
    231
  • 8
    「独家」AI视觉防御被彻底颠覆？无需训练、实时检测对抗样本，还能量化防御副作用的开源引擎问世
    170
  • 9
    用 200 元改了一个普通摄像头，测直径稳定到 ±5 微米
    232
  • 10
    【编号2401】告别窗口混乱：一款轻量化窗口管理工具的高效办公实践
    268

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    阿里云正式发布 Agentic 代码安全：AI驱动的双Agent协同引擎