AI 助理
备案控制台登录注册
开发者社区 大数据 文章 正文

二叉树（下）+Leetcode每日一题——“数据结构与算法”“对称二叉树”“另一棵树的子树”“二叉树的前中后序遍历”

2024-04-17 63 发布于浙江
版权
举报
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 二叉树（下）+Leetcode每日一题——“数据结构与算法”“对称二叉树”“另一棵树的子树”“二叉树的前中后序遍历”

这个题目需要重新定义一个函数，函数参数需要有左子树和右子树，题目所给定的函数无法解决问题。

bool _isSymmetric(struct TreeNode* leftRoot,struct TreeNode* rightRoot)
{
    //左子树和右子树同时为空
    if(leftRoot==NULL&&rightRoot==NULL)
    {
        return true;
    }
    //一棵树为空，另一棵树不为空
    if((leftRoot==NULL&&rightRoot!=NULL)||
    (leftRoot!=NULL&&rightRoot==NULL))
    {
        return false;
    }
    //左子树的根和右子树的根不相等
    //这就必然不对称
    if(leftRoot->val!=rightRoot->val)
    {
        return false;
    }
    return _isSymmetric(leftRoot->left,rightRoot->right)&&
            _isSymmetric(leftRoot->right,rightRoot->left);
}
bool isSymmetric(struct TreeNode* root){
    return _isSymmetric(root->left,root->right);
}

每个不为空的结点，都可以认为是一棵子树的根 

//两棵树相同
bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    //两个都为空
    if(p==NULL&&q==NULL)
    {
        return true;
    }
    //一个为空，另一个不为空
    if((p==NULL&&q!=NULL)||(p!=NULL&&q==NULL))
    {
        return false;
    }
    //根不相等
    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){
    if(root==NULL)
    {
        return false;
    }
    //root和subRoot相同
    if(isSameTree(root,subRoot))
    {
        return true;
    }
    //root的左子树与subRoot有相同或者root的右子树与subRoot有相同
    //满足其中一个条件即可，所以用||
    return isSubtree(root->left,subRoot)||
            isSubtree(root->right,subRoot);
}

递归里面传数组下标要注意！！！

每个栈帧里面都有一个数组下标！！！

所以要传数组下标的地址。

int TreeSize(struct TreeNode* root)
{
    return root==NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;
}
//递归里面传数组下标要注意！！！
//每个栈帧里面都有一个i
void preorder(struct TreeNode* root,int* a,int* pi)
{
    if(root==NULL)
    {
        return;
    }
    a[(*pi)++]=root->val;
    preorder(root->left,a,pi);
    preorder(root->right,a,pi);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize){
    //root是输入型参数，returnSize是返回型参数
    *returnSize=TreeSize(root);
    int* a=(int*)malloc(*returnSize*sizeof(int));
    int i=0;
    preorder(root,a,&i);
    return a;
}

当然，这个题目还有另外一种解法，就是把i作为全局变量，但是这样要特别注意，稍有不慎就会出错

int TreeSize(struct TreeNode* root)

{

   return root==NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;

}

//递归里面传数组下标要注意！！！

//每个栈帧里面都有一个i

int i=0;

void preorder(struct TreeNode* root,int* a)

{

   if(root==NULL)

   {

       return;

   }

   a[i++]=root->val;

   preorder(root->left,a);

   preorder(root->right,a);

}

int* preorderTraversal(struct TreeNode* root, int* returnSize){

   //root是输入型参数，returnSize是返回型参数

   *returnSize=TreeSize(root);

   int* a=(int*)malloc(*returnSize*sizeof(int));

   i=0;

   preorder(root,a);

   return a;

}

int TreeSize(struct TreeNode* root)

{

   return root==NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;

}

void inorder(struct TreeNode* root,int* a,int* pi)

{

   if(root==NULL)

   {

       return;

   }

   inorder(root->left,a,pi);

   a[(*pi)++]=root->val;

   inorder(root->right,a,pi);

}

int* inorderTraversal(struct TreeNode* root, int* returnSize){

   //root是输入型参数，returnSize是返回型参数

   *returnSize=TreeSize(root);

   int* a=(int*)malloc(*returnSize*sizeof(int));

   int i=0;

   inorder(root,a,&i);

   return a;

}

int TreeSize(struct TreeNode* root)

{

   return root==NULL?0:TreeSize(root->left)+TreeSize(root->right)+1;

}

void postorder(struct TreeNode* root,int* a,int* pi)

{

   if(root==NULL)

   {

       return;

   }

   postorder(root->left,a,pi);

   postorder(root->right,a,pi);

    a[(*pi)++]=root->val;

}

int* postorderTraversal(struct TreeNode* root, int* returnSize){

   //root是输入型参数，returnSize是返回型参数

   *returnSize=TreeSize(root);

   int* a=(int*)malloc(*returnSize*sizeof(int));

   int i=0;

   postorder(root,a,&i);

   return a;

}

层序遍历

除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层 上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

1出来带2和4，2出来带3和NULL，4出来带和6

写这个代码的核心是得有一个队列！！！

Queue.h的内容：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef struct BinaryTreeNode* QDataType;
// 链式结构：表示队列 
typedef struct QueueNode
{
  struct QueueNode* next;
  QDataType data;
}QueueNode;
// 队列的结构 
typedef struct Queue
{
  QueueNode* phead;//头指针
  QueueNode* ptail;//尾指针
  int size;
}Queue;
// 初始化队列
void QueueInit(Queue* pq);
 
// 销毁队列 
void QueueDestroy(Queue* pq);
 
// 队尾入队列 
void QueuePush(Queue* pq, QDataType x);
 
// 队头出队列 
void QueuePop(Queue* pq);
 
// 获取队列头部元素 
QDataType QueueFront(Queue* pq);
 
// 获取队列队尾元素 
QDataType QueueBack(Queue* pq);
 
// 获取队列中有效元素个数 
int QueueSize(Queue* pq);
 
// 检测队列是否为空
bool QueueEmpty(Queue* pq);

Queue.c的内容：

#include"Queue.h"
// 初始化队列
void QueueInit(Queue* pq)
{
  assert(pq);
  pq->phead = NULL;
  pq->ptail = NULL;
  pq->size = 0;
}
// 销毁队列 
void QueueDestroy(Queue* pq)
{
  assert(pq);
  QueueNode* cur = pq->phead;
  while (cur != NULL)
  {
    QueueNode* next = cur->next;
    free(cur);
    cur = next;
  }
  pq->phead = pq->ptail = NULL;
  pq->size = 0;
}
// 队尾入队列 
void QueuePush(Queue* pq, QDataType x)
{
  assert(pq);
  QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
  if (newnode == NULL)
  {
    perror("malloc fail");
    return;
  }
  newnode->data = x;
  newnode->next = NULL;
  //是空队列的情况
  if (pq->ptail == NULL)
  {
    assert(pq->phead == NULL);
    pq->phead = pq->ptail = newnode;
  }
  else
  {
    pq->ptail->next = newnode;
    pq->ptail = newnode;
  }
  pq->size++;
}
// 检测队列是否为空
bool QueueEmpty(Queue* pq)
{
  assert(pq);
  return pq->phead == NULL && pq->ptail == NULL;
}
// 队头出队列 
void QueuePop(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  //1.一个结点
  //2.多个结点
  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;
  }
  pq->size--;
}
// 获取队列头部元素 
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;
}
 
// 获取队列中有效元素个数 
int QueueSize(Queue* pq)
{
  assert(pq);
  return pq->size;
}

层序遍历源代码：

//层序遍历
void LevelOrder(BTNode* root)
{
  Queue q;
  QueueInit(&q);
  if (root != NULL)
  {
    QueuePush(&q, root);
  }
  while (!QueueEmpty(&q))
  {
    BTNode* front = QueueFront(&q);
    QueuePop(&q);
    printf("%d ", front->data);
    if (front->left != NULL)
    {
      QueuePush(&q, front->left);
    }
    if (front->right != NULL)
    {
      QueuePush(&q, front->right);
    }
  }
  printf("\n");
  QueueDestroy(&q);
}

二叉树销毁

//二叉树销毁
void BTreeDestroy(BTNode* root)
{
  if (root == NULL)
  {
    return;
  }
  BTreeDestroy(root->left);
  BTreeDestroy(root->right);
  free(root);
}

通 过 前 序 遍 历 的 数 组 " A B D # # E # H # # C F # # G # # " 构 建 二 叉 树

根        左子树        右子树

#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 = (BTNode*)malloc(sizeof(BTNode));
  if (node == NULL)
  {
    perror("malloc fail");
    return NULL;
  }
  node->data = x;
  node->left = NULL;
  node->right = NULL;
  return node;
}
BTNode* CreatTree(char* a,int* pi)
{
    if(a[*pi]=='#')
    {
        (*pi)++;
        return NULL;
    }
    BTNode* root=BuyNode(a[*pi]);
    (*pi)++;
    root->left=CreatTree(a,pi);
    root->right=CreatTree(a,pi);
    return root;
}
//中序
void InOrder(BTNode* root)
{
  if (root == NULL)
  {
    return;
  }
  InOrder(root->left);
  printf("%c ", root->data);
  InOrder(root->right);
}
int main()
{
    char a[100];
    scanf("%s",a);
    int i=0;
    BTNode*root=CreatTree(a,&i);
    InOrder(root);
    printf("\n");
    return 0;
 
}

判断二叉树是否是完全二叉树

完全二叉树的特征是：层序遍历去走，它是连续的！！！

1出来带2和4，2出来带3和NULL，4出来带5和6，3出来带NULL和NULL，但是，3后面的NULL的后面竟然还有非空，这就证明此树是一棵非完全二叉树。

1出来带2和4，2出来带3和7，4出来带5和6，3出来带8和NULL，7出来带NULL和NULL，5出来带NULL和NULL，6出来带NULL和NULL，8出来带NULL和NULL，也就是说，队列里面的全都是空了，这一定是一棵完全二叉树。

//判断二叉树是否是完全二叉树
bool BTreeComplete(BTNode* root)
{
  Queue q;
  QueueInit(&q);
  if (root != NULL)
  {
    QueuePush(&q, root);
  }
  while (!QueueEmpty(&q))
  {
    BTNode* front = QueueFront(&q);
    QueuePop(&q);
    //遇到空就跳出循环
    if (front == NULL)
    {
      break;
    }
    QueuePush(&q, front->left);
    QueuePush(&q, front->right);
  }
  //检查后面的结点有没有非空
  //有非空，就不是完全二叉树
  while (!QueueEmpty(&q))
  {
    BTNode* front = QueueFront(&q);
    QueuePop(&q);
    if (front != NULL)
    {
      QueueDestroy(&q);
      return false;
    }
  }
  QueueDestroy(&q);
  return true;
}

1.某完全二叉树按层次输出（同一层从左到右）的序列为 ABCDEFGH 。该完全二叉树的前序序列为（ A ）

A ABDHECFG

B ABCDEFGH

C HDBEAFCG

D HDEBFGCA

2.二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK;中序遍历：HFIEJKG.则二叉树根结点为（ A ）

A E

B F

C G

D H

此题与中序遍历无关（中序遍历是迷惑人的），光看先序遍历就可以看出来，先序遍历就是根        左子树        右子树，所以E就是根结点。

但如果是想还原出这棵二叉树，中序遍历就很重要啦！！！

3.设一棵二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树前序遍历序列为（ D ）。

A adbce

B decab

C debac

D abcde

后序遍历序列最后一个是a,所以a就是根节点！！！

4.某二叉树的后序遍历序列与中序遍历序列相同，均为 ABCDEF ，则按层次输出（同一层从左到右）的序列为（ A ）

A FEDCBA

B CBAFED

C DEFCBA

D ABCDEF

二叉树的性质

整个二叉树的源代码：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"Queue.h"
typedef int BTDataType;
typedef struct BinaryTreeNode
{
   BTDataType data;
   struct BinaryTreeNode* left;
   struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(BTDataType x)
{
   BTNode* node = (BTNode*)malloc(sizeof(BTNode));
   if (node == NULL)
   {
       perror("malloc fail");
       return NULL;
   }
   node->data = x;
   node->left = NULL;
   node->right = NULL;
   return node;
}

BTNode* CreatBinaryTree()
{
   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 = node4;
   node2->left = node3;
   node4->left = node5;
   node4->right = node6;
   return node1;
}

//前序
void PrevOrder(BTNode* root)
{
   if (root == NULL)
   {
       printf("NULL ");
       return;
   }
   printf("%d ", root->data);
   PrevOrder(root->left);
   PrevOrder(root->right);
}

//中序
void InOrder(BTNode* root)
{
   if (root == NULL)
   {
       printf("NULL ");
       return;
   }
   InOrder(root->left);
   printf("%d ", root->data);
   InOrder(root->right);
}

//后序
void PostOrder(BTNode* root)
{
   if (root == NULL)
   {
       printf("NULL ");
       return;
   }
   PostOrder(root->left);
   PostOrder(root->right);
   printf("%d ", root->data);
}

 

二叉树结点个数
//int size = 0;//全局变量
//int BTreeSize(BTNode* root)
//{
//    if (root == NULL)
//    {
//        return;
//    }
//    else
//    {
//        ++size;
//    }
//    BTreeSize(root->left);
//    BTreeSize(root->right);
//}
二叉树结点个数
//int BTreeSize(BTNode* root)
//{
//    if (root == NULL)
//    {
//        return 0;
//    }
//    else
//    {
//        return BTreeSize(root->left) + BTreeSize(root->right) + 1;
//    }
//}

//二叉树结点个数
int BTreeSize(BTNode* root)
{
   return root == NULL ? 0 : BTreeSize(root->left) + BTreeSize(root->right) + 1;
}

//求叶子结点的个数
int BTreeleafSize(BTNode* root)
{
   if (root == NULL)
   {
       return 0;
   }
   if (root->left == NULL && root->right == NULL)
   {
       return 1;
   }
   return BTreeleafSize(root->left) + BTreeleafSize(root->right);
}

//求二叉树的高度
int BTreeHeight(BTNode* root)
{
   if (root == NULL)
   {
       return 0;
   }
   else
   {
       int leftHeight = BTreeHeight(root->left);
       int rightHeight = BTreeHeight(root->right);
       return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
   }
}

// 二叉树第k层节点个数
int BTreeLevelKSize(BTNode* root, int k)
{
   assert(k > 0);
   if (root == NULL)//无论k是多少
   {
       return 0;
   }
   //root一定不为空
   if (k == 1)
   {
       return 1;
   }
   //root不为空并且k不为1
   return BTreeLevelKSize(root->left, k - 1) + BTreeLevelKSize(root->right, k - 1);
}

// 二叉树查找值为x的节点
BTNode* BTreeFind(BTNode* root, BTDataType x)
{
   if (root == NULL)
   {
       return NULL;
   }
   if (root->data == x)
   {
       return root;
   }
   BTNode* ret1 = BTreeFind(root->left, x);
   if (ret1)
   {
       return ret1;
   }
   BTNode* ret2 = BTreeFind(root->right, x);
   if (ret2)
   {
       return ret2;
   }
   return NULL;
}

//层序遍历
void LevelOrder(BTNode* root)
{
   Queue q;
   QueueInit(&q);
   if (root != NULL)
   {
       QueuePush(&q, root);
   }
   while (!QueueEmpty(&q))
   {
       BTNode* front = QueueFront(&q);
       QueuePop(&q);
       printf("%d ", front->data);
       if (front->left != NULL)
       {
           QueuePush(&q, front->left);
       }
       if (front->right != NULL)
       {
           QueuePush(&q, front->right);
       }
   }
   printf("\n");
   QueueDestroy(&q);
}

//二叉树销毁
void BTreeDestroy(BTNode* root)
{
   if (root == NULL)
   {
       return;
   }
   BTreeDestroy(root->left);
   BTreeDestroy(root->right);
   free(root);
}

//判断二叉树是否是完全二叉树
bool BTreeComplete(BTNode* root)
{
   Queue q;
   QueueInit(&q);
   if (root != NULL)
   {
       QueuePush(&q, root);
   }
   while (!QueueEmpty(&q))
   {
       BTNode* front = QueueFront(&q);
       QueuePop(&q);
       //遇到空就跳出循环
       if (front == NULL)
       {
           break;
       }
       QueuePush(&q, front->left);
       QueuePush(&q, front->right);
   }
   //检查后面的结点有没有非空
   //有非空，就不是完全二叉树
   while (!QueueEmpty(&q))
   {
       BTNode* front = QueueFront(&q);
       QueuePop(&q);
       if (front != NULL)
       {
           QueueDestroy(&q);
           return false;
       }
   }
   QueueDestroy(&q);
   return true;
}

int main()
{
   BTNode* root = CreatBinaryTree();
   PrevOrder(root);
   printf("\n");

   InOrder(root);
   printf("\n");

   PostOrder(root);
   printf("\n");

   /*BTreeSize(root);
   printf("BTreeSize:%d\n", size);

   size = 0;
   BTreeSize(root);
   printf("BTreeSize:%d\n", size);

   size = 0;
   BTreeSize(root);
   printf("BTreeSize:%d\n", size);*/

   printf("BTreeSize:%d\n",BTreeSize(root));

   printf("BTreeleafSize:%d\n", BTreeleafSize(root));

   printf("BTreeHeight:%d\n", BTreeHeight(root));

   printf("BTreeLevelKSize:%d\n", BTreeLevelKSize(root, 3));

   printf("BTreeFind:%p\n", BTreeFind(root, 3));

   LevelOrder(root);

   BTreeDestroy(root);
   root = NULL;

   return 0;
}

 

好啦，小雅兰的今日分享就到这里啦，还要继续加油学习噢！！！


文章标签：
API
算法
DataX
关键词：
LeetCode二叉树
数据结构树
算法树
数据结构遍历
数据结构树遍历
认真学习的小雅兰.
+关注
148文章
目录
打赏
0
0
0
0
4
分享
相关文章
飞川001
|
2月前
|
Go 开发者 索引
【LeetCode 热题100】路径与祖先：二叉树中的深度追踪技巧（力扣33 / 81/ 153/154）（Go语言版）
本文深入探讨了LeetCode中四道关于「搜索旋转排序数组」的经典题目，涵盖了无重复和有重复元素的情况。通过二分查找的变形应用，文章详细解析了每道题的解题思路和Go语言实现代码。关键点包括判断有序区间、处理重复元素以及如何缩小搜索范围。文章还总结了各题的异同，并推荐了类似题目，帮助读者全面掌握二分查找在旋转数组中的应用。无论是初学者还是有经验的开发者，都能从中获得实用的解题技巧和代码实现方法。
飞川001
214 14
飞川001
|
3月前
|
Go
【LeetCode 热题100】路径与祖先：二叉树中的深度追踪技巧（力扣437 / 236 ）（Go语言版）
本文深入探讨二叉树中路径与祖先问题，涵盖两道经典题目：LeetCode 437（路径总和 III）和236（最近公共祖先）。对于路径总和 III，文章分析了双递归暴力解法与前缀和优化方法，后者通过哈希表记录路径和，将时间复杂度从O(n²)降至O(n)。在最近公共祖先问题中，采用后序遍历递归查找，利用“自底向上”的思路确定最近公共祖先节点。文中详细解析代码实现与核心要点，帮助读者掌握深度追踪技巧，理解树结构中路径与节点关系的本质。这类问题在面试中高频出现，掌握其解法意义重大。
飞川001
81 4
飞川001
|
3月前
|
算法 Go
【LeetCode 热题100】深入理解二叉树结构变化与路径特性（力扣104 / 226 / 114 / 543）（Go语言版）
本博客深入探讨二叉树的深度计算、结构变换与路径分析，涵盖四道经典题目：104（最大深度）、226（翻转二叉树）、114（展开为链表）和543（二叉树直径）。通过递归与遍历策略（前序、后序等），解析每题的核心思路与实现方法。结合代码示例（Go语言），帮助读者掌握二叉树相关算法的精髓。下一讲将聚焦二叉树构造问题，欢迎持续关注！
飞川001
84 10
飞川001
|
3月前
|
存储 算法 数据可视化
【二叉树遍历入门：从中序遍历到层序与右视图】【LeetCode 热题100】94:二叉树的中序遍历、102:二叉树的层序遍历、199:二叉树的右视图（详细解析）（Go语言版）
本文详细解析了二叉树的三种经典遍历方式：中序遍历（94题）、层序遍历（102题）和右视图（199题）。通过递归与迭代实现中序遍历，深入理解深度优先搜索（DFS）；借助队列完成层序遍历和右视图，掌握广度优先搜索（BFS）。文章对比DFS与BFS的思维方式，总结不同遍历的应用场景，为后续构造树结构奠定基础。
飞川001
186 10
飞川001
|
3月前
|
Go 索引 Perl
【LeetCode 热题100】【二叉树构造题精讲：前序 + 中序建树 & 有序数组构造 BST】（详细解析）（Go语言版）
本文详细解析了二叉树构造的两类经典问题：通过前序与中序遍历重建二叉树（LeetCode 105），以及将有序数组转化为平衡二叉搜索树（BST，LeetCode 108）。文章从核心思路、递归解法到实现细节逐一拆解，强调通过索引控制子树范围以优化性能，并对比两题的不同构造逻辑。最后总结通用构造套路，提供进阶思考方向，帮助彻底掌握二叉树构造类题目。
飞川001
189 9
简简单单做算法
|
1月前
|
机器学习/深度学习 算法 数据挖掘
基于WOA鲸鱼优化的BiLSTM双向长短期记忆网络序列预测算法matlab仿真,对比BiLSTM和LSTM
本项目基于MATLAB 2022a/2024b实现，采用WOA优化的BiLSTM算法进行序列预测。核心代码包含完整中文注释与操作视频，展示从参数优化到模型训练、预测的全流程。BiLSTM通过前向与后向LSTM结合，有效捕捉序列前后文信息，解决传统RNN梯度消失问题。WOA优化超参数（如学习率、隐藏层神经元数），提升模型性能，避免局部最优解。附有运行效果图预览，最终输出预测值与实际值对比，RMSE评估精度。适合研究时序数据分析与深度学习优化的开发者参考。
简简单单做算法
57 0
简简单单做算法
|
1月前
|
机器学习/深度学习 算法 数据安全/隐私保护
基于GA遗传优化的BiLSTM双向长短期记忆网络序列预测算法matlab仿真,对比BiLSTM和LSTM
本内容包含基于BiLSTM与遗传算法（GA）的算法介绍及实现。算法通过MATLAB2022a/2024b运行，核心为优化BiLSTM超参数（如学习率、神经元数量），提升预测性能。LSTM解决传统RNN梯度问题，捕捉长期依赖；BiLSTM双向处理序列，融合前文后文信息，适合全局信息任务。附完整代码（含注释）、操作视频及无水印运行效果预览，适用于股票预测等场景，精度优于单向LSTM。
简简单单做算法
68 0
简简单单做算法
|
22天前
|
机器学习/深度学习 算法 数据安全/隐私保护
基于PSO粒子群优化的BiLSTM双向长短期记忆网络序列预测算法matlab仿真,对比BiLSTM和LSTM
本项目基于MATLAB2022a/2024b开发，结合粒子群优化（PSO）算法与双向长短期记忆网络（BiLSTM），用于优化序列预测任务中的模型参数。核心代码包含详细中文注释及操作视频，涵盖遗传算法优化过程、BiLSTM网络构建、训练及预测分析。通过PSO优化BiLSTM的超参数（如学习率、隐藏层神经元数等），显著提升模型捕捉长期依赖关系和上下文信息的能力，适用于气象、交通流量等场景。附有运行效果图预览，展示适应度值、RMSE变化及预测结果对比，验证方法有效性。
简简单单做算法
50 6
我爱matlab
|
27天前
|
算法 JavaScript 数据安全/隐私保护
基于遗传算法的256QAM星座图的最优概率整形matlab仿真,对比优化前后整形星座图和误码率
本内容展示了基于GA（遗传算法）优化的256QAM概率星座整形（PCS）技术的研究与实现。通过Matlab仿真，分析了优化前后星座图和误码率（BER）的变化。256QAM采用非均匀概率分布（Maxwell-Boltzman分布）降低外圈星座点出现频率，减小平均功率并增加最小欧氏距离，从而提升传输性能。GA算法以BER为适应度函数，搜索最优整形参数v，显著降低误码率。核心程序实现了GA优化过程，包括种群初始化、选择、交叉、变异等步骤，并绘制了优化曲线。此研究有助于提高频谱效率和传输灵活性，适用于不同信道环境。
我爱matlab
48 10
软件算法开发
|
22天前
|
机器学习/深度学习 算法
基于遗传优化ELM网络的时间序列预测算法matlab仿真
本项目实现了一种基于遗传算法优化的极限学习机（GA-ELM）网络时间序列预测方法。通过对比传统ELM与GA-ELM，验证了参数优化对非线性时间序列预测精度的提升效果。核心程序利用MATLAB 2022A完成，采用遗传算法全局搜索最优权重与偏置，结合ELM快速训练特性，显著提高模型稳定性与准确性。实验结果展示了GA-ELM在复杂数据中的优越表现，误差明显降低。此方法适用于金融、气象等领域的时间序列预测任务。
软件算法开发
32 3
AI助理

你好，我是AI助理

可以解答问题、推荐解决方案等

登录插画

登录以查看您的控制台资源

管理云资源
状态一览
快捷访问
快捷注册登录阿里云