二叉树算法题

最新推荐文章于 2021-12-27 20:07:05 发布
最新推荐文章于 2021-12-27 20:07:05 发布
阅读量237 收藏
点赞数
分类专栏： 数据与结构 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a331683772/article/details/106931703
版权
  1. 二叉树的前序遍历
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
  //  vector<int> res;
    vector<int> preorderTraversal(TreeNode* root) {
   /*     if(root != NULL)
       {
             res.push_back(root->val);
             preorderTraversal(root->left);
             preorderTraversal(root->right);
       }
        return res;
    */
    vector<int> res;
    stack<TreeNode*>call;
    if(root != NULL)call.push(root);
     while(!call.empty())
     {
          TreeNode* tmp = call.top();
          call.pop();
          if(tmp != NULL)
          {
            if(tmp->right) call.push(tmp->right);
            if(tmp->left) call.push(tmp->left);
            call.push(tmp);
            call.push(NULL);
          }
          else
          {
              res.push_back(call.top()->val);
              call.pop();
          }

     }
     return res;
    }
};
  1. 二叉树中序遍历
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
   // vector<int> res;
    vector<int> inorderTraversal(TreeNode* root) {
    /*    if(root != NULL)
        {
              inorderTraversal(root->left);
              res.push_back(root->val);
              inorderTraversal(root->right);
        }
        return res;
        */
        vector<int> res;
        stack<TreeNode*> call;
        if(root != NULL) call.push(root);
        while(!call.empty())
        {
            TreeNode* tmp = call.top();
            call.pop();
            if(tmp != NULL)
            {
                if(tmp->right) call.push(tmp->right);
                call.push(tmp);
                call.push(NULL);
                if(tmp->left) call.push(tmp->left);
            }
            else
            {
                res.push_back(call.top()->val);
                call.pop();
            }
        }
        return res;
    }
};
  1. 二叉树的后序遍历
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
   // vector<int> res;
    vector<int> postorderTraversal(TreeNode* root) {
    /*    if(root != NULL)
        {
            postorderTraversal(root->left);
            postorderTraversal(root->right);
            res.push_back(root->val);
        }
        return res;
        */
        vector<int> res;
        stack<TreeNode*> call;
        if(root != NULL) call.push(root);
        while(!call.empty())
        {
            TreeNode* tmp = call.top();
            call.pop();
            if(tmp != NULL)
            {
                if(tmp != NULL) call.push(tmp);
                call.push(NULL);
                if(tmp->right) call.push(tmp->right);
                if(tmp->left) call.push(tmp->left);      
            }
            else
            {
                res.push_back(call.top()->val);
                call.pop();
            }
        }
        return res;
    }
};
  1. 二叉树的层序遍历 。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
         vector<vector<int>> res;
         if(root == nullptr)
         return res;
         queue<TreeNode*>q;
         q.push(root);
         while(!q.empty())
         {
             vector<int> tmp;
             int size = q.size();
             for(int i = 0;i < size;i++)
             {
                 TreeNode* Ttmp = q.front();
                 q.pop();
                 tmp.push_back(Ttmp->val);
                 if(Ttmp->left) q.push(Ttmp->left);
                 if(Ttmp->right) q.push(Ttmp->right);
             }
             res.push_back(tmp);
         }
         return res;
    }
};
  1. 检查两颗树是否相同。c
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
       if(p == NULL && q != NULL)
            return false;
        if(p != NULL && q == NULL)
            return false;
        if(p == NULL && q==NULL)
            return true;
        if(p->val != q->val)
        return false;
        return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
        
      /*  stack<TreeNode*>S;
        S.push(p);
        S.push(q);
        while(!S.empty())
        {
            TreeNode* q = S.top();
            S.pop();
             TreeNode* p = S.top();
            S.pop();
            if(q==NULL && p==NULL) continue;
            if(q!=NULL && p==NULL) return false;
            if(q==NULL && p!=NULL) return false;
            if(q->val != p->val) return false;
            else
            {
                S.push(p->left);
                S.push(q->left);
                S.push(q->right);
                S.push(p->right);
            }
        }
        return true;
        */
    }
};
  1. 对称二叉树。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
       return isSymmetric(root,root);
    }
    bool isSymmetric(TreeNode* q,TreeNode* p) {
      /* if(root1 != NULL && root2 == NULL)
       return false;
        if(root1 == NULL && root2 != NULL)
       return false;
      if(root1 == NULL && root == NULL)
       return true;
       if(root1->val != root2->val)
       return false;
       return isSymmetric(root1->left,root2->right) &&
               isSymmetric(root1->right,root2->left);
               */
        stack<TreeNode*>S;
        S.push(p);
        S.push(q);
        while(!S.empty())
        {
            TreeNode* q = S.top();
            S.pop();
             TreeNode* p = S.top();
            S.pop();
            if(q==NULL && p==NULL) continue;
            if(q!=NULL && p==NULL) return false;
            if(q==NULL && p!=NULL) return false;
            if(q->val != p->val) return false;
            else
            {
                S.push(p->left);
                S.push(q->right);
                S.push(q->left);
                S.push(p->right);
            }
        }
        return true;
    }
};
  1. 另一颗树的子树。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool dfs(TreeNode* s,TreeNode* t)
    {
        if(s == NULL && t==NULL) return true;
        if(s == NULL || t == NULL) return false;
        if(s->val != t->val) return false;
        return dfs(s->left,t->left) && dfs(s->right,t->right);
    }
    bool isSubtree(TreeNode* s, TreeNode* t) {
        if(s == NULL) return false;
        if(dfs(s,t)) return true;
        return isSubtree(s->left,t) || isSubtree(s->right,t);
    }
};
  1. 二叉树最大深度。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == NULL) return 0;
        int l = maxDepth(root->left)+1;
        int r = maxDepth(root->right)+1;
        return l>r?l:r;
    }
};

class Solution {
public:
    int maxDepth(TreeNode* root) {
         if(root==NULL) return 0;
         deque<TreeNode*> q;
         q.push_back(root);
         int deep=0;
         while(!q.empty())
         {
             deep++;
             int num=q.size();
             for(int i=1;i<=num;i++)
             {
                TreeNode* p=q.front();
                q.pop_front();
                if(p->left) q.push_back(p->left);
                if(p->right) q.push_back(p->right);
             }
         }
         return deep;         
    }
};
  1. 二叉树的构建及遍历。
#include<iostream>
#include<string>
using namespace std;
string str;
int i;
struct TreeNode
{
    char val;
    struct TreeNode* lchild,*rchild;
    TreeNode(char c) :val(c),lchild(NULL),rchild(NULL){};
};
TreeNode* createTree()
{
    char c = str[i++];
    if(c == '#') return NULL;
    TreeNode *root = new TreeNode(c);
    root->lchild = createTree();
    root->rchild = createTree();
    return root;
}
void inOrderTraversal(TreeNode* root)
{
    if(!root) return;
    inOrderTraversal(root->lchild);
    cout<<root->val<<" ";
    inOrderTraversal(root->rchild);
}

int main()
{
    while(cin>>str)
    {
        i = 0;
        TreeNode *root = createTree();
        inOrderTraversal(root);
        cout<<endl;
    }
    return 0;
}
  1. 二叉树创建字符串。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void preAccess(TreeNode* t,string& str)
    {
        if(t == NULL) return;
        str += to_string(t->val);
        if(t->left || t->right)
        {
            str += "(";
            preAccess(t->left,str);
            str += ")";
        }
        if(t->right)
        {
            str += "(";
            preAccess(t->right,str);
            str += ")";
        }
    }
    string tree2str(TreeNode* t) {
        string res = "";
        preAccess(t,res);
        return res;
    }
};
  1. 判断一颗二叉树是否是平衡二叉树。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        return box(root) != -1;
    }

    int box(TreeNode* root)
    {
        if(root == NULL) return 0;
        int l = box(root->left);
        if(l == -1) return -1;
        int r = box(root->right);
        if(r == -1) return -1;
        return abs(l-r) < 2 ? max(l,r)+1:-1;

    }
};

c
12. 根据一棵树的前序遍历与中序遍历构造二叉树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int size = inorder.size();
        if(size == 0)
        return NULL;
        TreeNode* root = new TreeNode(preorder[0]);
        vector<int>pre_left,vin_left,pre_right,vin_right;
        int head = 0;
        while(inorder[head] != preorder[0])
           head++;
        for(int i = 0;i < head;i++)
        {
            pre_left.push_back(preorder[i+1]);
            vin_left.push_back(inorder[i]);
        }

        for(int i = head+1;i < size;i++)
        {
            pre_right.push_back(preorder[i]);
            vin_right.push_back(inorder[i]);
        }
        root->left = buildTree(pre_left,vin_left);
        root->right = buildTree(pre_right,vin_right);
        return root;
    }
};
  1. 根据一棵树的中序遍历与后序遍历构造二叉树。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int size = postorder.size();
        if(size == 0)
        return NULL;
        int  head = 0;
        TreeNode* root = new TreeNode(postorder[size-1]);
        while(inorder[head] != postorder[size-1])
        head++;
        vector<int> vin_left,post_left,vin_right,post_right;
        for(int i = 0;i < head;i++)
        {
            vin_left.push_back(inorder[i]);
            post_left.push_back(postorder[i]);
        }
        for(int i = head+1;i < size;i++)
        {
            vin_right.push_back(inorder[i]);
            post_right.push_back(postorder[i-1]);
        }
        root->left = buildTree(vin_left,post_left);
        root->right = buildTree(vin_right,post_right);
        return root;
        
    }
};
  1. 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* res;
    bool dfs(TreeNode* root, TreeNode* p, TreeNode* q)
    {
        if(root == NULL) return false;
        int lson = dfs(root->left,p,q);
        int rson = dfs(root->right,p,q);
        if((lson&&rson) || ((root->val==p->val||root->val == q->val) &&(lson || rson)))
        {
            res = root;
        }
        return lson || rson ||(root->val==p->val||root->val == q->val);
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        dfs(root,p,q);
        return res;
    }
};

二叉树最远节点

int HeightOfBinaryTree(BinaryTreeNode*pNode, int&nMaxDistance){
	if (pNode == NULL)
		return -1;   //空节点的高度为-1
	//递归
	int nHeightOfLeftTree = HeightOfBinaryTree(pNode->m_pLeft, nMaxDistance) + 1;   //左子树的的高度加1
	int nHeightOfRightTree = HeightOfBinaryTree(pNode->m_pRight, nMaxDistance) + 1;   //右子树的高度加1
	int nDistance = nHeightOfLeftTree + nHeightOfRightTree;    //距离等于左子树的高度加上右子树的高度+2
	nMaxDistance = nMaxDistance > nDistance ? nMaxDistance : nDistance;            //得到距离的最大值
	return nHeightOfLeftTree > nHeightOfRightTree ? nHeightOfLeftTree : nHeightOfRightTree;
}
ChengQianO
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树面试题
08-28
以下是一些关于二叉树的常见面试题及解题思路： 1. **定义与基本术语**： - 二叉树是每个节点最多有两个子节点的树结构，通常分为左子节点和右子节点。 - 节点包含一个值，可能有零个、一个或两个子节点。 - ...
二叉树算法题汇总
热门推荐
一念永恒
05-19 1万+
目录 二叉树的遍历 前序遍历 中序遍历 后序遍历 层次遍历 基础算法 求二叉树中的节点个数 求二叉树的深度（高度） 求二叉树第k层的节点个数 求二叉树中叶子节点的个数 判断两棵二叉树是否相同的树 判断二叉树是不是平衡二叉树 求二叉树的镜像 判断两个二叉树是否互相镜像 判断是否为二分查找树BST 本文的实例代码基于JAVA编写 首先给出节点的数据结构 publi...
二叉树-算法题
HUIxihuanni的博客
01-05 227
前话： 二叉树的深度优先搜素和广度优先搜索： 1、广度优先搜索（BFS) 宽度优先搜索写为BFS,其过程检验来说就是对每一层节点依次访问，访问这一层浸润下一层，而且每个节点只能访问一次。对于上面的例子来说，广度优先遍历的结果是：3->9->20->15->7。 宽度优先遍历各个节点，需要使用队列这种数据结构，queue的特点是先进先...
Java二叉树算法实例.zip_java 二叉树_二叉树
09-22
这个名为"Java二叉树算法实例.zip"的压缩包显然是一个针对初学者的教程，旨在帮助他们理解并掌握二叉树的基本概念和常见算法。 首先，二叉树是由节点构成的数据结构，每个节点包含两个子节点，分别称为左子节点和右...
二叉树模板代码 二叉树习题
03-20
二叉树是一种重要的数据结构，广泛应用于计算机科学的多个领域，如算法设计、数据库系统、编译器等。本主题将深入探讨二叉树的基本概念、常见操作以及模板代码实现，帮助你理解和解决二叉树相关的习题。 一、二叉树...
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
在LeetCode的第94题中，目标是实现一个函数来返回给定二叉树的中序遍历结果。这个题目考察的是对二叉树遍历的理解以及如何用编程语言（这里可能是Python）来实现这个操作。 首先，我们来看第一种解题方法，即递归...
经典算法题大全
04-22
【标题】"经典算法题大全"揭示了这个压缩包的核心内容——它是一个包含大量算法问题的集合，专门针对像蓝桥杯这样的编程竞赛。蓝桥杯是中国一项知名的计算机编程比赛，旨在提升参赛者的算法设计与实现能力。这些题目...
二叉树树的算法题目
maoloveyu_ecstc的博客
07-12 428
一、二叉树中用递归实现的各种题目总结 1.将一棵二叉树转化成双向链表     二叉树转化成双向链表的过程，就是中序遍历的过程。问题的关键是如何将在遍历二叉树的同时，修改指针指向，满足双向要求。   public TreeNode Convert(TreeNode root) { if(root==null)return null; if(root.left==
二叉树相关算法题
qq_41735433的博客
11-13 144
1.二叉树前序遍历非递归版 思路：使用一个栈（为了让遍历的节点可以从树的底层回到上层），先添加右子树再添加左子树 public static void preOrder(Node root) { Stack<Node> stack = new Stack<>(); stack.push(root); while (!stack.isEmpty()) { Node node = stack.pop();
二叉树常见算法题（单值二叉树、二叉树的最大深度、反转二叉树、判断两颗二叉树是否相同、对称二叉树、一颗二叉树是否是另一颗二叉树的子树）
weixin_62042704的博客
12-27 1587
这里的代码都是递归实现的，再强调下二叉树的概念，二叉树的构成有两种情况： 1、空树 2、根节点 + 左子树 + 右子树（这里的左子树和右子树又是一颗二叉树） 可以看出二叉树就是递归定义的，下面的算法题中大多都要用到这个思想。 一、单值二叉树 1、题目要求： 2、解法： 这个也就是遍历二叉树，然后判断它是否和根节点的值相同，前序、中序、后序遍历都可以。 3、代码： bool _isUnivalTree(struct TreeNode* root,int num){ if(root.
算法题---二叉树篇
单向街的夏天
05-24 1002
1 问题：打印二叉树所有的路径  给一个二叉树，把所有的路径都打印出来。 比如，对于下面这个二叉树，它所有的路径为： 8 -> 3 -> 1 8 -> 2 -> 6 -> 4 8 -> 3 -> 6 -> 7 8 -> 10 -> 14 -> 13 思路： 从根节点开始，把自己的值放在一个数组里，然后把这个数组传给它的子节点，子节点同样把自己
二叉树算法趣题
lansebolangcjl的专栏
02-23 342
二叉树中的节点x含有一个变量wealth表征了该节点的财富，定义二叉树中节点x的Heritage为其祖先节点（包括x）的所有wealth之和减去节点x的子孙节点的所有wealth之和。求二叉树中Heritage最大的节点及其值。【要求不能改变原有二叉树的结构，不能在节点之上存储别的信息，算法复杂度尽量简单】
完全二叉树会出什么算法题
最新发布
03-06
因为完全二叉树的特殊性，所以在算法题中常常会涉及到对完全二叉树的操作和遍历。 以下是一些可能出现的与完全二叉树相关的算法题： 1. 验证完全二叉树：给定一个二叉树，判断它是否是完全二叉树。 2. 完全二叉树...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值