devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【二叉树】—— 算法题

作者：小舞很执着 | 2024-08-17 01:29:35

赞

踩

【二叉树】—— 算法题

一、单值二叉树

        题目要求：判断二叉树是不是单值二叉树（就是所以节点的值都相等）。

思路：

        利用二叉树的递归思想，判断每一个节点值与其左右子节点的值是否相等，如果遇到空节点，就返回true（说明每一个节点值都相等）；如果遇到节点的值与其左右节点值不相等就返回false；如果该节点的值与其左右子节点的值都相等，就接着递归该节点的左右子树。

代码如下：

  1. bool isUnivalTree(struct TreeNode* root) {
  2.     if (root == NULL) {
  3.         return true;
  4.     }
  5.     if (root->left && root->left->val != root->val) {
  6.         return false;
  7.     }
  8.     if (root->right && root->right->val != root->val) {
  9.         return false;
  10.     }
  11.  
  12.     return isUnivalTree(root->left) && isUnivalTree(root->right);
  13. }

二、相同的树 — 对称二叉树 — 另一颗树的子树

        2.1、相同的树

        判断两个二叉树是否相等

思路：

        同时遍历两个二叉树，如果遍历到两个二叉树节点同时为空，就说明这两个二叉树相同；如果其中一个为空而另一个不为空，就说明两个二叉树不相同；如果遍历过程中，遇到两个二叉树节点的值不相等，则两个二叉树不相同。

简单分析一下：

        同时遍历这两个二叉树

        两个二叉树节点都不为空且值相等，继续遍历其左子树

        两个二叉树节点都不为空且值相等，继续遍历其左子树

        两个二叉树节点都为空，返回true

        先遍历二叉树是2节点的右节点，也为空，这里直接跳过了。

        这里回退到1这个节点，接下来遍历1的右子树

        遍历到节点都不为空，且值相等，继续遍历 （这因为3的左右节点都为空，就一步带过）

        遍历结束，没有遇到一个节点为空一个节点不为空或者值不相等的情况，就返回true。

代码如下：

  1. typedef struct TreeNode TreeNode;
  2. bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
  3.     if (p == NULL && q == NULL) {
  4.         return true;
  5.     }
  6.     if (p == NULL || q == NULL) {
  7.         return false;
  8.     }
  9.     if (p->val != q->val) {
  10.         return false;
  11.     }
  12.     return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
  13. }

        2.2、对称二叉树

        

        判断二叉树是否是对称二叉树，这里还是实现与上题相同的树类似的思路。

思路：

        利用相同的树的方法，判断二叉树根节点的左右子树是否对称（判断对称直接判断一个节点的左子树和另一个节点的右子树是否相等即可）。

代码如下：

  1. typedef struct TreeNode TreeNode;
  2. bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
  3.     if (p == NULL && q == NULL) {
  4.         return true;
  5.     }
  6.     if (p == NULL || q == NULL) {
  7.         return false;
  8.     }
  9.     if (p->val != q->val) {
  10.         return false;
  11.     }
  12.     return isSameTree(p->left, q->right) && isSameTree(p->right, q->left);
  13. }
  14. bool isSymmetric(struct TreeNode* root) {
  15.     return isSameTree(root->left,root->right);
  16. }

        2.3、另一颗树的子树

        判断一个树是否是另一个树的子树

思路：

        还是利用相同二叉树的方法，判断二叉树及其左右子树中是否存在与另一棵树相同的树。

代码如下：

  1. typedef struct TreeNode TreeNode;
  2. bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
  3.     if (p == NULL && q == NULL) {
  4.         return true;
  5.     }
  6.     if (p == NULL || q == NULL) {
  7.         return false;
  8.     }
  9.     if (p->val != q->val) {
  10.         return false;
  11.     }
  12.     return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
  13. }
  14.  
  15. bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
  16.     if(root==NULL)
  17.     {
  18.         return false;
  19.     }
  20.     if(isSameTree(root,subRoot))
  21.     {
  22.         return true;
  23.     }
  24.  
  25.     return isSubtree(root->left,subRoot)
  26.             ||isSubtree(root->right,subRoot);
  27. }

三、二叉树的遍历（前序、中序、后序）

        本题要求，前序遍历二叉树，并且返回前序遍历的结果（以数组方式返回），并且还用通过指向修改数据个数。

思路：

        这里首先求二叉树的节点个数；然后动态申请内存来存储数据并且用来最后返回数组首元素地址；最后就是将数据存储到数组当中了，使用前序遍历。

代码如下：

  1. typedef struct TreeNode TreeNode;
  2. int TreeSize(TreeNode* root) {
  3.     if (root == NULL) {
  4.         return 0;
  5.     }
  6.     return TreeSize(root->left) + TreeSize(root->right) + 1;
  7. }
  8. void _preorderTraversal(TreeNode* root,int* arr,int* pi)
  9. {
  10.     if(root==NULL)
  11.     {
  12.         return ;
  13.     }
  14.     arr[(*pi)++]=root->val;
  15.     _preorderTraversal(root->left,arr,pi);
  16.     _preorderTraversal(root->right,arr,pi);
  17. }
  18. int* preorderTraversal(struct TreeNode* root, int* returnSize) {
  19.  
  20.     // 求出二叉树的节点个数
  21.     *returnSize =TreeSize(root);
  22.     // 动态申请空间大小
  23.     int* returnArr=(int*)malloc(sizeof(int)*(*returnSize));
  24.     // 前序遍历
  25.     int i=0;
  26.     _preorderTraversal(root,returnArr,&i);
  27.     return returnArr;
  28. }

中序和后序遍历与其思路一样这里直接看代码。

中序遍历

  1.  typedef struct TreeNode TreeNode;
  2. int TreeSize(TreeNode* root) {
  3.     if (root == NULL) {
  4.         return 0;
  5.     }
  6.     return TreeSize(root->left) + TreeSize(root->right) + 1;
  7. }
  8. void _inorderTraversal(TreeNode* root,int* arr,int* pi)
  9. {
  10.     if(root==NULL)
  11.     {
  12.         return ;
  13.     }
  14.     _inorderTraversal(root->left,arr,pi);
  15.     arr[(*pi)++]=root->val;
  16.     _inorderTraversal(root->right,arr,pi);
  17. }
  18. int* inorderTraversal(struct TreeNode* root, int* returnSize) {
  19.  
  20.     // 求出二叉树的节点个数
  21.     *returnSize =TreeSize(root);
  22.     // 动态申请空间大小
  23.     int* returnArr=(int*)malloc(sizeof(int)*(*returnSize));
  24.     // 中序遍历
  25.     int i=0;
  26.     _inorderTraversal(root,returnArr,&i);
  27.     return returnArr;
  28. }

后序遍历

  1.   typedef struct TreeNode TreeNode;
  2. int TreeSize(TreeNode* root) {
  3.     if (root == NULL) {
  4.         return 0;
  5.     }
  6.     return TreeSize(root->left) + TreeSize(root->right) + 1;
  7. }
  8. void _postorderTraversal(TreeNode* root,int* arr,int* pi)
  9. {
  10.     if(root==NULL)
  11.     {
  12.         return ;
  13.     }
  14.     _postorderTraversal(root->left,arr,pi);
  15.     _postorderTraversal(root->right,arr,pi);
  16.     arr[(*pi)++]=root->val;
  17. }
  18. int* postorderTraversal(struct TreeNode* root, int* returnSize) {
  19.  
  20.     // 求出二叉树的节点个数
  21.     *returnSize =TreeSize(root);
  22.     // 动态申请空间大小
  23.     int* returnArr=(int*)malloc(sizeof(int)*(*returnSize));
  24.     // 中序遍历
  25.     int i=0;
  26.     _postorderTraversal(root,returnArr,&i);
  27.     return returnArr;
  28. }

四、二叉树的构建和遍历

        创建二叉树，并且中序遍历。

因为这里题目说先序遍历字符串（我们根据这个来构建二叉树），本题要求写全部代码。

思路：

        先创建字符数组，根据输入的字符串进行创建二叉树，创建完成以后再进行中序遍历输出即可。

代码如下：

  1. #include <stdio.h>
  2. #include<stdlib.h>
  3. typedef struct BinaryTreeNode
  4. {
  5.     char str;
  6.     struct BinaryTreeNode* left;
  7.     struct BinaryTreeNode* right;
  8. }BTNode;
  9.  
  10. BTNode* BuyNode(char x)
  11. {
  12.     BTNode* newnode=(BTNode* )malloc(sizeof(BTNode));
  13.     newnode->str=x;
  14.     newnode->left=newnode->right=NULL;
  15.     return newnode;
  16. }
  17. BTNode* CreatTree(char* str,int* pi)
  18. {
  19.     if(str[*pi]=='#')
  20.     {
  21.         (*pi)++;
  22.         return NULL;
  23.     }
  24.     BTNode* root=BuyNode(str[(*pi)++]);
  25.     root->left=CreatTree(str,pi);
  26.     root->right=CreatTree(str,pi);
  27.     return root;
  28. }
  29. //中序遍历
  30. void InOrder(BTNode* root)
  31. {
  32.     if(root==NULL)
  33.     {
  34.         return;
  35.     }
  36.     InOrder(root->left);
  37.     printf("%c ",root->str);
  38.     InOrder(root->right);
  39. }
  40. int main() {
  41.     char str[100];
  42.     scanf("%s",str);
  43.     //根据字符创建二叉树
  44.     int i=0;
  45.     BTNode* root=CreatTree(str, &i);
  46.     InOrder(root);
  47.     return 0;
  48. }

感谢各位大佬支持并指出问题，

                        如果本篇内容对你有帮助，可以一键三连支持以下，感谢支持！！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/990629
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号