AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

仅不到五万字轻松了解二叉树和堆 4

2022-05-16 83
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 仅不到五万字轻松了解二叉树和堆
4、二叉树的前序遍历＜难度系数⭐＞

📝 题述：给你二叉树的根节点 root ，返回它节点值的前序遍历。

💨 示例 1：

输入：root = [1,null,2,3]

输出：[1,2,3]

💨 示例 2：

输入：root = []

输出：[]

💨 示例 3：

输入：root = [1]

输出：[1]

💨 示例 4：

输入：root = [1,2]

输出：[1,2]

💨 示例 5：

输入：root = [1,null,2]

输出：[1,2]

⚠ 注意：

1️⃣ 树中节点数目在范围 [0, 100] 内

2️⃣ -100 <= Node.val <= 100

🧷 平台：Visual studio 2017 && windows

🔑 核心思想：先实现 TreeSize 计算出二叉树的节点个数给 returnSize，并开辟好 returnSize 个 int 类型大小的数组。再调用子函数进行前序递归：如果每层函数栈帧中节点为空则结束栈帧，否则把节点放到数组里，并继续递归

leetcode原题

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int BTDataType;
typedef struct TreeNode 
{
  int val;
  struct TreeNode *left;
  struct TreeNode *right;
}BTNode;
//malloc空间
BTNode* BuyNode(BTDataType x)
{
  BTNode* node = malloc(sizeof(BTNode));
  node->val = x;
  node->left = NULL;
  node->right = NULL;
  return node;
}
//创建树
BTNode* CreatBinaryTree()
{
  BTNode* node1 = BuyNode(1);
  BTNode* node2 = BuyNode(2);
  BTNode* node3 = BuyNode(3);
  node1->right = node2;
  node2->left = node3;
  return node1;
}
//求二叉树节点的个数
int TreeSize(struct TreeNode* root)
{
  if (root == NULL)
  {
    return 0;
  }
  return TreeSize(root->left) + TreeSize(root->right) + 1;
}
//子函数用于递归 - 使用前序的方式
void _preorderTraversal(struct TreeNode* root, int* arr, int* pi)
{
  if (root == NULL)
    return;
  //放节点
  arr[(*pi)++] = root->val;
  _preorderTraversal(root->left, arr, pi);
  _preorderTraversal(root->right, arr, pi);
}
//Note: The returned array must be malloced, assume caller calls free().
 //二叉树的前序遍厉
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
  //*returnSize用于接收二叉树的节点个数
  *returnSize = TreeSize(root);
  //开辟*returnSize个int类型大小的空间
  int* arr = (struct TreeSize*)malloc(sizeof(int)* *returnSize);
  //因为preorderTraversal不适合递归，所以需要一个子函数；这里每一次递归都是一层函数栈帧，所以对于i来说想要保留正确的下标就要传地址
  int i = 0;
  _preorderTraversal(root, arr, &i);
  return arr;
}
int main()
{
  int returnSize = 0;
  BTNode* root = CreatBinaryTree();
  int* arr = preorderTraversal(root, &returnSize);
  return 0;
}
5、二叉树中序遍历＜难度系数⭐＞

📝 题述：给定一个二叉树的根节点 root ，返回它的中序遍历。

💨 示例 1：

输入：root = [1,null,2,3]

输出：[1,2,3]

💨 示例 2：

输入：root = []

输出：[]

💨 示例 3：

输入：root = [1]

输出：[1]

💨 示例 4：

输入：root = [1,2]

输出：[1,2]

💨 示例 5：

输入：root = [1,null,2]

输出：[1,2]

⚠ 注意：

1️⃣ 树中节点数目在范围 [0, 100] 内

2️⃣ -100 <= Node.val <= 100

🧷 平台：Visual studio 2017 && windows

🔑 核心思想：类似前序

leetcode原题

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int BTDataType;
typedef struct TreeNode
{
  int val;
  struct TreeNode *left;
  struct TreeNode *right;
}BTNode;
//malloc空间
BTNode* BuyNode(BTDataType x)
{
  BTNode* node = malloc(sizeof(BTNode));
  node->val = x;
  node->left = NULL;
  node->right = NULL;
  return node;
}
//创建树
BTNode* CreatBinaryTree()
{
  BTNode* node1 = BuyNode(1);
  BTNode* node2 = BuyNode(2);
  BTNode* node3 = BuyNode(3);
  node1->right = node2;
  node2->left = node3;
  return node1;
}
//求二叉树节点的个数
int TreeSize(struct TreeNode* root)
{
  if (root == NULL)
  {
    return 0;
  }
  return TreeSize(root->left) + TreeSize(root->right) + 1;
}
//子函数用于递归 - 使用中序的方式
void _inorderTraversal(struct TreeNode* root, int* arr, int* pi)
{
    if(root == NULL)
        return;
    _inorderTraversal(root->left, arr, pi);
    arr[(*pi)++] = root->val;
    _inorderTraversal(root->right, arr, pi);
}
//Note: The returned array must be malloced, assume caller calls free().
//二叉树的中序遍厉
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    //*returnSize接收二叉树的节点个数
    *returnSize = TreeSize(root);
    //开辟*returnSize个int类型大小的空间
    int* arr = (struct TreeNode*)malloc(sizeof(int)* * returnSize);
    //递归调用子函数
    int i = 0;
    _inorderTraversal(root, arr, &i);
    return arr;
}
int main()
{
  int returnSize = 0;
  BTNode* root = CreatBinaryTree();
  int* arr = inorderTraversal(root, &returnSize);
  return 0;
}
6、二叉树的后序遍历＜难度系数⭐＞

📝 题述：给定一个二叉树，返回它的后序遍历。

💨 示例 ：

输入: [1,null,2,3]

输出: [3,2,1]

🧷 平台：Visual studio 2017 && windows

🔑 核心思想：类似前序

leetcode原题

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int BTDataType;
typedef struct TreeNode
{
  int val;
  struct TreeNode *left;
  struct TreeNode *right;
}BTNode;
//malloc空间
BTNode* BuyNode(BTDataType x)
{
  BTNode* node = malloc(sizeof(BTNode));
  node->val = x;
  node->left = NULL;
  node->right = NULL;
  return node;
}
//创建树
BTNode* CreatBinaryTree()
{
  BTNode* node1 = BuyNode(1);
  BTNode* node2 = BuyNode(2);
  BTNode* node3 = BuyNode(3);
  node1->right = node2;
  node2->left = node3;
  return node1;
}
//求二叉树节点的个数
int TreeSize(struct TreeNode* root)
{
  if (root == NULL)
  {
    return 0;
  }
  return TreeSize(root->left) + TreeSize(root->right) + 1;
}
//子函数用于递归 - 使用后序的方式
void _postorderTraversal(struct TreeNode* root, int* arr, int* pi)
{
  if (root == NULL)
    return;
  _postorderTraversal(root->left, arr, pi);
  _postorderTraversal(root->right, arr, pi);
  arr[(*pi)++] = root->val;
}
//Note: The returned array must be malloced, assume caller calls free().
//二叉树的后序遍历
int* postorderTraversal(struct TreeNode* root, int* returnSize) {
  //*returnSize接收二叉树的节点个数
  *returnSize = TreeSize(root);
  //开辟*returnSize个int类型大小的空间
  int* arr = (struct TreeNode*)malloc(sizeof(int)* * returnSize);
  //递归调用子函数
  int i = 0;
  _postorderTraversal(root, arr, &i);
  return arr;
}
int main()
{
  int returnSize = 0;
  BTNode* root = CreatBinaryTree();
  int* arr = postorderTraversal(root, &returnSize);
  return 0;
}
7、另一颗树的子树＜难度系数⭐＞

📝 题述：给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

💨 示例 1：

输入：root = [3,4,5,1,2], subRoot = [4,1,2]

输出：true

💨 示例 2：

输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]

输出：false

⚠ 注意：

1️⃣ root 树上的节点数量范围是 [1, 2000]

2️⃣ subRoot 树上的节点数量范围是 [1, 1000]

3️⃣ -104 <= root.val <= 104

4️⃣ -104 <= subRoot.val <= 104

🧷 平台：Visual studio 2017 && windows

🔑 核心思想：每一层函数栈帧中都包括：如果 root 等于空，返回 false；如果调用相同的树为真，返回 true；否则继续递归

leetcode原题

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int BTDataType;
typedef struct TreeNode 
{
  int val;
  struct TreeNode *left;
  struct TreeNode *right;
}BTNode;
//malloc空间
BTNode* BuyNode(BTDataType x)
{
  BTNode* node = malloc(sizeof(BTNode));
  node->val = x;
  node->left = NULL;
  node->right = NULL;
  return node;
}
//创建树1
BTNode* CreatBinaryTree1()
{
  BTNode* node1 = BuyNode(3);
  BTNode* node2 = BuyNode(4);
  BTNode* node3 = BuyNode(5);
  BTNode* node4 = BuyNode(1);
  BTNode* node5 = BuyNode(2);
  node1->left = node2;
  node1->right = node3;
  node2->left = node4;
  node2->right = node5;
  return node1;
}
//创建树2
BTNode* CreatBinaryTree2()
{
  BTNode* node1 = BuyNode(4);
  BTNode* node2 = BuyNode(1);
  BTNode* node3 = BuyNode(2);
  node1->left = node2;
  node1->right = node3;
  return node1;
}
//相同的树
bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
  //p为空，q也为空
  if (p == NULL && q == NULL)
    return true;
  //p和q只有1个为空
  if (p == NULL || q == NULL)
    return false;
  //p和q的val不等
  if (p->val != q->val)
    return false;
  //相等递归
  return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
//另一棵树的子树
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot) {
  //root等于空
  if (root == NULL)
    return false;
  //调用相同的树
  if (isSameTree(root, subRoot))
    return true;
  //继续递归
  return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}
int main()
{
  BTNode* root1 = CreatBinaryTree1();
  BTNode* root2 = CreatBinaryTree2();
  printf("%d\n", isSubtree(root1, root2));
  return 0;
}
8、二叉树的构建及遍历＜难度系数⭐＞

📝 题述：编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

输入描述：

   输入包括1行字符串，长度不超过 100。

输出描述：

   可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个

   空格。 每个输出结果占一行。

💨 示例 ：

   输入：abc##de#g##f###

   输出：c b e g d f a

🧷 平台：Visual studio 2017 && windows

🔑 核心思想：

❗ 注意此题不同于上面的几道接口题，这里是 I/O 类型的题需要我们自己创建树 ❕

根据题意中先序遍历的字符串可以得到：

先前序构建树，再中序输出树

nowcode原题

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
struct TreeNode
{
  char val;
  struct TreeNode* left;
  struct TreeNode* right;
};
//前序构建树
struct TreeNode* CreatTree(char* str, int* pi)
{
  if (str[*pi] == '#')
  {
    //空树数组的下标也要++，且为它malloc空间
    (*pi)++;
    return NULL;
  }
  //malloc空间
  struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
  //前序递归
  root->val = str[(*pi)++];
  root->left = CreatTree(str, pi);
  root->right = CreatTree(str, pi);
  return root;
}
//中序输出树
void InOrder(struct TreeNode* root)
{
  if (root == NULL)
    return;
  InOrder(root->left);
  printf("%c ", root->val);
  InOrder(root->right);
}
int main()
{
  char str[100];
  scanf("%s", str);
  int i = 0;
  struct TreeNode* root = CreatTree(str, &i);
  InOrder(root);
  return 0;
}

💦 二叉树的创建和销毁

//二叉树创建
BTNode* BinaryCreatBinaryTree();
// 二叉树销毁
void BinaryTreeDestroy(BTNode* root);

❗ BinaryCreatBinaryTree && BinaryTreeDestroy ❕

    注意对于 BinaryTreeDestroy 使用后序的方式销毁

#include<stdio.h>
#include<stdlib.h>
typedef int BTDataType;
typedef struct BinaryTreeNode
{
  BTDataType _data;
  struct BinaryTreeNode* _left;
  struct BinaryTreeNode* _right;
}BTNode;
BTNode* BuyNode(BTDataType x)
{
  BTNode* node = malloc(sizeof(BTNode));
  node->_data = x;
  node->_left = NULL;
  node->_right = NULL;
  return node;
}
//创建二叉树
BTNode* BinaryCreatBinaryTree()
{
  BTNode* node1 = BuyNode(1);
  BTNode* node2 = BuyNode(2);
  BTNode* node3 = BuyNode(3);
  BTNode* node4 = BuyNode(4);
  BTNode* node5 = BuyNode(5);
  BTNode* node6 = BuyNode(6);
  node1->_left = node2;
  node1->_right = node3;
  node2->_left = node4;
  node3->_left = node5;
  node3->_right = node6;
  return node1;
}
//后序销毁二叉树
void BinaryTreeDestroy(BTNode* root)
{
  if (root == NULL)
    return;
  BinaryTreeDestroy(root->_left);
  BinaryTreeDestroy(root->_right);
  free(root);
}
int main()
{
  BTNode* root = BinaryCreatBinaryTree();
  BinaryTreeDestroy(root);
  root = NULL;
  return 0;
}

💦 二叉树的层序遍厉

//层序遍厉
void BinaryTreeLeveOrder(BTNode* root);
//判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root);

BinaryTreeLeveOrder：

🔑 核心思想 🔑

    使用队列的方式：先入第一层，出上一层，再入下一层 … …

    需要使用之前实现的队列

BinaryTreeComplete：

🔑 核心思想 🔑

    想必完全二叉树在此处出现一定跟层序有关系

    层序遍厉，把空也入队列

    完全二叉树，非空是连续的，空也是连续的

    非完全二叉树，非空就不是连续的，空也是不连续的

❗ 这里需要三个文件 ❕

    1️⃣ Queue_LeveOrder.h，用于函数的声明

#pragma once
//头
#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<stdlib.h>
//结构体
typedef struct BinaryTreeNode*  QDataType;
typedef struct QueueNode
{
  struct QueueNode* next; //指向下一个节点
  QDataType data; //存储整型数据
}QueueNode;
typedef struct Queue
{
  QueueNode* phead;//头指针
  QueueNode* ptail;//尾指针
}Queue;
//函数
void QueueInit(Queue* pq); 
void QueuePush(Queue* pq, QDataType x); 
bool QueueEmpty(Queue* pq);
void QueuePop(Queue* pq);
QDataType QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
void QueueDestory(Queue* pq);

    2️⃣ Queue_LeveOrder.c，用于函数的实现

#include"Queue_LeveOrder.h"
void QueueInit(Queue* pq)
{
  assert(pq);
  //把2个指针置空
  pq->phead = pq->ptail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
  assert(pq);
  //malloc空间,如果需要频繁的开辟空间建议再实现一个BuyQueueNode用于malloc
  QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
  if (newnode == NULL)
  {
    printf("malloc fail\n");
    exit(-1);
  }
  newnode->data = x;
  newnode->next = NULL;
  //第一次插入
  if (pq->phead == NULL)
  {
    pq->phead = pq->ptail = newnode;
  }
  //非第一次插入
  else
  {
    pq->ptail->next = newnode;
    pq->ptail = newnode;
  }
}
bool QueueEmpty(Queue* pq)
{
  assert(pq);
  //空链表返回true，非空链表返回false
  return pq->phead == NULL;
}
void QueuePop(Queue* pq)
{
  assert(pq);
  //链表为空时不能删除
  assert(!QueueEmpty(pq));
  //只有一个节点的情况
  if (pq->phead->next == NULL)
  {
    free(pq->phead);
    pq->phead = pq->ptail = NULL;
  }
  //多个节点的情况
  else
  {
    QueueNode* next = pq->phead->next;
    free(pq->phead) ;
    pq->phead = next;
  }
}
QDataType QueueSize(Queue* pq)
{
  assert(pq);
  //如果需要频繁的调用QueueSize这个接口，可以在Queue这个结构体中增加一个成员用于记录长度
  int sz = 0;
  QueueNode* cur = pq->phead;
  while (cur)
  {
    sz++;
    cur = cur->next;
  }
  return sz;
}
QDataType QueueFront(Queue* pq)
{
  assert(pq);
  //链表为空时不能取头
  assert(!QueueEmpty(pq));
  return pq->phead->data;
}
QDataType QueueBack(Queue* pq)
{
  assert(pq);
  //链表为空时不能取尾
  assert(!QueueEmpty(pq));
  return pq->ptail->data;
}
void QueueDestory(Queue* pq)
{
  assert(pq);
  QueueNode* cur = pq->phead;
  //遍历链表
  while (cur)
  {
    QueueNode* next = cur->next;
    free(cur);
    cur = next;
  }
  pq->phead = pq->ptail = NULL;
}

    3️⃣ Test.c，用于函数的测试

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef int BTDataType;
typedef struct BinaryTreeNode
{
  BTDataType _data;
  struct BinaryTreeNode* _left;
  struct BinaryTreeNode* _right;
}BTNode;
//从此处包含Queue.h文件
#include"Queue_LeveOrder.h"
BTNode* BuyNode(BTDataType x)
{
  BTNode* node = malloc(sizeof(BTNode));
  node->_data = x;
  node->_left = NULL;
  node->_right = NULL;
  return node;
}
//创建二叉树
BTNode* BinaryCreatBinaryTree()
{
  BTNode* node1 = BuyNode(1);
  BTNode* node2 = BuyNode(2);
  BTNode* node3 = BuyNode(3);
  BTNode* node4 = BuyNode(4);
  BTNode* node5 = BuyNode(5);
  BTNode* node6 = BuyNode(6);
  node1->_left = node2;
  node1->_right = node3;
  node2->_left = node4;
  node3->_left = node5;
  node3->_right = node6;
  return node1;
}
//层序遍厉
void BinaryTreeLeveOrder(BTNode* root)
{
  Queue q;
  QueueInit(&q);
  if (root)
  {
    //入队列
    QueuePush(&q, root);
  }
  while (!QueueEmpty(&q))
  {
    //取队头的数据
    BTNode* front = QueueFront(&q);
    //出队
    QueuePop(&q);
    printf("%d ", front->_data);
    if (front->_left)
    {
      //入左子树
      QueuePush(&q, front->_left);
    }
    if (front->_right)
    {
      //入右子树
      QueuePush(&q, front->_right);
    }
  }
  printf("\n");
  QueueDestory(&q);
}
//判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{
  Queue q;
  QueueInit(&q);
  if (root)
  {
    //入队列
    QueuePush(&q, root);
  }
  while (!QueueEmpty(&q))
  {
    //取队头的数据
    BTNode* front = QueueFront(&q);
    //出队
    QueuePop(&q);
    //遇到空就break出去再判断
    if(front == NULL)
    {
      break;
    }
    //入左子树
    QueuePush(&q, front->_left);
    //入右子树
    QueuePush(&q, front->_right);
  }
  //队列中全是空，就是完全二叉树；还有非空，就不是完全二叉树
  while(!QueueEmpty(&q))
  {
    BTNode* front = QueueFront(&q);
    QueuePop(&q);
    //非空
    if(front)
    {
      QueueDestory(&q);
      return false;
    }
  }
  //全是空
  QueueDestory(&q);
  return true;
}
//后序销毁二叉树
void BinaryTreeDestroy(BTNode* root)
{
  if (root == NULL)
    return;
  BinaryTreeDestroy(root->_left);
  BinaryTreeDestroy(root->_right);
  free(root);
}
int main()
{
  BTNode* root = BinaryCreatBinaryTree();
  BinaryTreeLeveOrder(root);
  printf("BinaryTreeComplete:%d\n", BinaryTreeComplete(root));
  BinaryTreeDestroy(root);
  root = NULL;
  return 0;
}
文章标签：
Windows
存储
跳动的bit
目录
相关文章
南瓜佬
|
4天前
|
弹性计算 关系型数据库 微服务
基于 Docker 与 Kubernetes（K3s）的微服务：阿里云生产环境扩容实践
在微服务架构中，如何实现“稳定扩容”与“成本可控”是企业面临的核心挑战。本文结合 Python FastAPI 微服务实战，详解如何基于阿里云基础设施，利用 Docker 封装服务、K3s 实现容器编排，构建生产级微服务架构。内容涵盖容器构建、集群部署、自动扩缩容、可观测性等关键环节，适配阿里云资源特性与服务生态，助力企业打造低成本、高可靠、易扩展的微服务解决方案。
南瓜佬
1106 0
modelscope
|
3天前
|
机器学习/深度学习 人工智能 前端开发
通义DeepResearch全面开源！同步分享可落地的高阶Agent构建方法论
通义研究团队开源发布通义 DeepResearch —— 首个在性能上可与 OpenAI DeepResearch 相媲美、并在多项权威基准测试中取得领先表现的全开源 Web Agent。
modelscope
508 10
2025「AI安全」全球攻防赛小编
|
13天前
|
人工智能 运维 安全
从“裸奔”到“金钟罩”：AI身份凭据安全的进化之路
构建身份权限安全，护航企业数据合规
2025「AI安全」全球攻防赛小编
1277 33
aliyun7937252284-32777
|
12天前
|
人工智能 测试技术 API
智能体（AI Agent）搭建全攻略：从概念到实践的终极指南
在人工智能浪潮中，智能体（AI Agent）正成为变革性技术。它们具备自主决策、环境感知、任务执行等能力，广泛应用于日常任务与商业流程。本文详解智能体概念、架构及七步搭建指南，助你打造专属智能体，迎接智能自动化新时代。
aliyun7937252284-32777
1294 9
南瓜佬
|
4天前
|
弹性计算 Kubernetes jenkins
如何在 ECS/EKS 集群中有效使用 Jenkins
本文探讨了如何将 Jenkins 与 AWS ECS 和 EKS 集群集成，以构建高效、灵活且具备自动扩缩容能力的 CI/CD 流水线，提升软件交付效率并优化资源成本。
南瓜佬
301 0
弹性计算-百晓生
|
11天前
|
人工智能 异构计算
敬请锁定《C位面对面》，洞察通用计算如何在AI时代持续赋能企业创新，助力业务发展！
敬请锁定《C位面对面》，洞察通用计算如何在AI时代持续赋能企业创新，助力业务发展！
弹性计算-百晓生
1045 11
modelscope
|
12天前
|
机器学习/深度学习 人工智能 自然语言处理
B站开源IndexTTS2，用极致表现力颠覆听觉体验
在语音合成技术不断演进的背景下，早期版本的IndexTTS虽然在多场景应用中展现出良好的表现，但在情感表达的细腻度与时长控制的精准性方面仍存在提升空间。为了解决这些问题，并进一步推动零样本语音合成在实际场景中的落地能力，B站语音团队对模型架构与训练策略进行了深度优化，推出了全新一代语音合成模型——IndexTTS2 。
modelscope
803 23
兵临天下19970108016
|
4天前
|
缓存 供应链 监控
VVIC seller_search 排行榜搜索接口深度分析及 Python 实现
VVIC搜款网seller_search接口提供服装批发市场的商品及商家排行榜数据，涵盖热销榜、销量排名、类目趋势等，支持多维度筛选与数据分析，助力选品决策、竞品分析与市场预测，为服装供应链提供有力数据支撑。
兵临天下19970108016
207 118
兵临天下19970108016
|
4天前
|
缓存 监控 API
Amazon item_review 商品评论接口深度分析及 Python 实现
亚马逊商品评论接口（item_review）可获取用户评分、评论内容及时间等数据，支持多维度筛选与分页调用，结合Python实现情感分析、关键词提取与可视化，助力竞品分析、产品优化与市场决策。
兵临天下19970108016
202 117