二叉树的面试题

最新推荐文章于 2024-05-08 21:12:40 发布
最新推荐文章于 2024-05-08 21:12:40 发布
阅读量1.1k 收藏 1
点赞数 3
分类专栏： 数据结构 c和c++语言 文章标签： 二叉树的面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34992845/article/details/75041981
版权
1. 求两个节点的最近公共祖先节点假设现在找的是节点X1和X2的最近的公共祖先节点。 这里由于这棵树的结构或者说是特点从而导致这颗树的解法会有多种思路：第一种就是这棵二叉树是一个搜索二叉树，那么可以根据搜索二叉树的特点从而找出两个节点的最近的公共祖先节点。 可以想到，如果X1在一个节点的左子树，X2在一个节点的右子树，或者X1在一个节点的右子树，而X2在一个节点的左子树，这样就可以
摘要由CSDN通过智能技术生成

1. 求两个节点的最近公共祖先节点

这里写图片描述

假设现在找的是节点X1和X2的最近的公共祖先节点。
这里由于这棵树的结构或者说是特点从而导致这颗树的解法会有多种思路：

第一种就是这棵二叉树是一个搜索二叉树，那么可以根据搜索二叉树的特点从而找出两个节点的最近的公共祖先节点。
可以想到，如果X1在一个节点的左子树，X2在一个节点的右子树，或者X1在一个节点的右子树，而X2在一个节点的左子树，这样就可以说明该节点一定就是X1和X2的最近的公共祖先节点。
这里应该注意一个小问题：就是图中2和3的最近的公共祖先节点应该是3.

简单描述下这个过程：
如果X1这个节点比遍历到的当前节点大，则说明X1这个节点肯定在当前节点的左子树中，如果X1这个节点比遍历到的当前节点小，则说明X1这个节点一定在当前节点的右子树中，然后就是只要可以判断出节点X1和节点X2分别位于一个节点的左子树和右子树中，那么就可以返回这个节点（这个节点即就是我们所求的X1和X2的最近的公共祖先节点）。
使用递归就很容易写出代码。这种方法的时间复杂度是o(N)。

第二种是如果这棵二叉树的结构是一种三叉链的结构，那么可以从X1节点开始，直至根节点，将这条路径保存在一个数组里，然后再从X2节点开始遍历至根节点，将这条路径保存在另一个数组里。然后用其中一个数组中的第一个节点开始去另一个数组中查找，如果找到相同的，则就说明该节点就是这两个节点的公共祖先节点，如果没有找到相同的，则继续用第二个节点用同样的方法遍历另一个数组，直至找到相同的节点。
但是这种方法的时间复杂度是O(N^2)。

第三种就是上面图中最为普通的二叉树，这种普通二叉树去查找任意两个节点的最近的公共祖先节点思路可以参考一下上面二叉搜索树的方法，利用一个Find的接口函数，在一个节点的左子树去查找X1，如果找不到，再去该节点的右子树去查找，将查找的结果记录下来，再利用Find的接口函数去右子树查找X2，如果找不到，则去该节点个左子树去查找。最后利用他们查找的结果来判断这两个节点的最近的公共祖先节点。
这种思路的时间复杂度依然是O(N^2)。

template<class T>
class BinaryTree
{
public:

    template<class T>
    struct BinaryTreeNode
    {
        BinaryTreeNode* _left;
        BinaryTreeNode* _right;
        T _val;
        BinaryTreeNode(const T& val)
            :_left(NULL)
            , _right(NULL)
            , _val(val)
        {}
        BinaryTreeNode()
            :_left(NULL)
            , _right(NULL)
        {}
    };

    typedef BinaryTreeNode<T> Node;

    BinaryTree()
        :_root(NULL)
    {}


    bool Find(Node* x)
    {
        assert(x);
        return _Find(_root,x);
    }


    //时间复杂度是O(N^2)
    Node* GetLastCommonAncestor(Node* x1, Node* x2)
    {
        assert(x1 && x2);
        if (_root == NULL)
        {
            return NULL;
        }
        return _GetLastCommonAncestor(_root, x1, x2);
    }

private:

    Node* _Find(Node* root, const T& x)
    {
        if (root == NULL)
        {
            return NULL;
        }
        if (root->_val == x)
        {
            return root;
        }
        Node* l = _Find(root->_left, x);
        if (l == NULL)
        {
            return _Find(root->_right, x);
        }   
    }

    Node* _GetLastCommonAncestor(Node* root, Node* x1, Node* x2)
    {
        //在子树中
        if (root == x1 || _root == x2)
        {
            return root;
        }

        bool x1InLeft = false, x1InRight = false, x2InLeft = false, x2InRight = false;
        x1InLeft = _Find(root->_left, x1);
        if (x1InLeft == false)
        {
            x1InRight = _Find(root->_right, x1);
        }
        x2InLeft = _Find(root->_left, x2);
        if (x2InLeft == false)
            x2InRight = _Find(root->_right, x2);

        if (x1InLeft && x2InRight || x1InRight && x2InLeft)//一个节点在左子树，一个节点在右子树
        {
            return root;
        }
        else if (x1InLeft && x2InLeft)//两个节点都在左子树
        {
            return _GetLastCommonAncestor(root->_left, x1, x2);
        }
        else if (x1InRight && x2InRight)//两个节点都在右子树
        {
            return _GetLastCommonAncestor(root->_right, x1, x2);
        }
    }

    bool _Find(Node* root, Node* x)
    {
        if (root == NULL)
        {
            return false;
        }
        if (root == x)
        {
            return true;
        }
        bool l = _Find(root->_left, x);
        if (l)
            return true;
        return _Find(root->_right, x);
    }

    Node* _root;
};

不过这种思路还是可以优化的，逻辑思路类似于上面三叉链的方法。
就是在找一个节点时，就将查找的路径直接保存到一个栈里。
另一个节点采用同样的方法，将查找的路径保存到另一个栈里。
然后需要保证这两个栈中节点的个数是相等的，很简单，让节点个数大的出几次栈就好，直至两个栈中节点的个数是相等的。然后取出两个栈的栈顶元素，如果相等，则该栈顶元素就是我们所求的最近的公共祖先节点，如果不等，那么就让两个栈同时出栈，接着比较。
这种思路的时间复杂度是O(N)。

template<class T>
class BinaryTree
{
public:

    template<class T>
    struct BinaryTreeNode
    {
        BinaryTreeNode* _left;
        BinaryTreeNode* _right;
        T _val;
        BinaryTreeNode(const T& val)
            :_left(NULL)
            , _right(NULL)
            , _val(val)
        {}
        BinaryTreeNode()
            :_left(NULL)
            , _right(NULL)
        {}
    };

    typedef BinaryTreeNode<T> Node;

    BinaryTree()
        :_root(NULL)
    {}


    bool Find(Node* x)
    {
        assert(x);
        return _Find(_root,x);
    }

        //时间复杂度为O(N)
    Node* GetLastCommonAncestor(Node* x1, Node* x2)
    {
        assert(x1 && x2);
        stack<Node*> x1paths;
        stack<Node*> x2paths;
        Find(x1, x1paths);
        Find(x2, x2paths);
        while (x1paths.size() != x2paths.size())
        {
            if (x1paths.size() > x2paths.size())
            {
                x1paths.pop();
            }
            else
            {
                x2paths.pop();
            }
        }
        while (!x1paths.empty() && !x2paths.empty() && x1paths.top() != x2paths.top())
        {
            x1paths.pop();
            x2paths.pop();
        }
        if (x1paths.top() == x2paths.top())
        {
            return x1paths.top();
        }
        return NULL;
    }

    bool Find(Node* x, stack<Node*>& paths)
    {
        return _Find(_root, x, paths);
    }

private:
    bool _Find(Node* root, Node* x, stack<Node*>& paths)
    {
        if (root == NULL)
        {
            return false;
        }
        paths.push(root);

        if (root == x)
        {
            return true;
        }
        //说明：只要找到就可以直接返回了
        bool l = _Find(root->_left, x, paths);
        if (l == true)
        {
            return true;
        }
        bool r = _Find(root->_right, x, paths);
        if (r == true)
        {
            return true;
        }
            paths.pop();//到这里就说明在一个节点的左右子树中都没有找到，那么就可以pop出该节点，给递归程序的上层返回false
            return false;
    }


    bool _Find(Node* root, Node* x)
    {
        if (root == NULL)
        {
            return false;
        }
        if (root == x)
        {
            return true;
        }
        bool l = _Find(root->_left, x);
        if (l)
            return true;
        return _Find(root->_right, x);
    }

    Node* _root;
};

2. 判断一棵二叉树是否是平衡二叉树【y】

平衡二叉树，即就是要求一棵二叉树的左右高度差是否小于等于1。

思路参考：
第三题
时间复杂度为O(N^2)
先判断当前节点是否为平衡二叉树就需要遍历整棵二叉树，求得左右子树的高度，然后递归判断左子树是否为平衡二叉树，又需要遍历左子树求得左子树的高度，判断右子树是否为平衡二叉树，需要遍历右子树求得右子树的高度，这里面会有很多的冗余值。将越接近叶子节点的节点的高度求了很多次，这都是没有必要的，下面会将其优化。

//时间复杂度为O(N^2)
    bool _IsBalance(Node* root)
    {
        if (root == NULL)
        {
            return true;
        }
        int l = _Height(root->_left);
        int r = _Height(root->_right);

        //到这里说明已经是二叉树了
        return abs(l - r) < 2
            && _IsBalance(root->_left)
        && _IsBalance(root->_right);
    }

size_t _Height(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        size_t leftlen = 0, rightlen = 0;
        if (root->_left)
         leftlen = _Height(root->_left);
        if (root->_right)
         rightlen = _Height(root->_right);
        return leftlen > rightlen ? leftlen + 1 : rightlen + 1;
    }

时间复杂度为O(N)

利用函数的参数列表将每一个节点的高度带回上层递归程序中。
也就是从叶子节点开始判断该棵子树是否为平衡二叉树。

//时间复杂度为O(N)
    bool _IsBalance(Node* root, int& depth)
    {
        if (root == NULL)
        {
            depth = 0;
            return true;
        }
        int ldepth = 0, rdepth = 0;
        if (_IsBalance(root->_left, ldepth) == false)
        {
            return false;
        }
        if (_IsBalance(root->_right, rdepth) == false)
        {
            return false;
        }
        if (abs(ldepth - rdepth) > 1)
        {
            return false;
        }
        depth = ldepth > rdepth ? ldepth + 1 : rdepth + 1;//这棵子树已经是平衡二叉树了
        return true;
    }

3. 求二叉树中最远的两个节点的距离

在遇到这个问题的时候，一开始我想的就是使用递归，我们先来考虑这样一个问题，如何判断一个子树中最远两个节点的距离？是不是只要把一个子树的左子树和右子树的高度分别求出来，然后将这两个值相加就是该子树最远两个节点的距离。但是需要不断更新最远距离，因为当前树中的最远的两个 节点的距离不一定就是该二叉树中最远两个节点的距离，就用上图来说明这个问题吧

这里写图片描述

根节点为6的这棵二叉树的最远距离就是6.
而根节点为5的这棵二叉树的最远距离就是8，所以并不是根节点为6的这棵子树所求出的最远距离就是这棵二叉树真正的最远距离。

求最远距离时需要求每个子树的左右高度，第一方法是按照正常思路从根节点开始求出根节点的左右高度，然后将左右高度相加得到第一个maxlen（最远距离）的值，随后就是不断递归左子树向下查找每个节点的左右高度，然后更新maxlen的值，左子树遍历到叶子节点时就可以回溯了，回溯到达根节点然后不断递归右子树求出每个节点的左右高度然后更新maxlen的值，最终回溯回根节点后就求出了maxlen的值。

但是这个过程有很多的冗余值，就是在求根节点6的左右高度时，其实已经把左子树和右子树中每一个节点的高度求过一次了，一次求节点的高度，假设左右子树每次平分，时间复杂度就是O(N)，而需要递归求每个节点的左右子树高度，遍历每个节点，这个时间复杂度又是O（N）,递归的时间复杂度就是递归的总次数*每次递归的次数。所以这种思路的时间复杂度就是O（N^2），这种思路的效率是不是太低了呢。

template<class T>
class BinaryTree
{
public:

    template<class T>
    struct BinaryTreeNode
    {
        BinaryTreeNode* _left;
        BinaryTreeNode* _right;
        T _val;
        BinaryTreeNode(const T& val)
            :_left(NULL)
            , _right(NULL)
            , _val(val)
        {}
        BinaryTreeNode()
            :_left(NULL)
            , _right(NULL)
        {}
    };

    typedef BinaryTreeNode<T> Node;

    BinaryTree()
        :_root(NULL)
    {}
//时间复杂度：O(N^2)
    void FindMaxLen(size_t& Maxlen)//不断更新最远距离
    {
        _FindMaxLen(_root, Maxlen);
    }

private:

void _FindMaxLen(Node* root, size_t& Maxlen)
    {

        size_t leftlen = 0, rightlen = 0;
        if (root->_left)
            leftlen = _Height(root->_left);
        if (root->_right)
            rightlen = _Height(root->_right);
        if (leftlen + rightlen > Maxlen)
        {
            Maxlen = leftlen + rightlen;
        }
        if (root->_left)
            _FindMaxLen(root->_left, Maxlen);
        if (root->_right)
            _FindMaxLen(root->_right, Maxlen);
    }

size_t _Height(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        size_t leftlen = 0, rightlen = 0;
        if (root->_left)
         leftlen = _Height(root->_left);
        if (root->_right)
         rightlen = _Height(root->_right);
        return leftlen > rightlen ? leftlen + 1 : rightlen + 1;
    }

    Node* _root;
};

我们来思考一下上面的思路可不可以优化呢？
如果我们想从叶子节点4开始求高度，然后将4的高度返回给4的父亲8，接着再求8的左右子树高度（利用4返回的高度）不需要再重新求4的高度，而且只要求出每个节点的左右子树高度就可以更新该节点的最远距离，那么要完成这样的逻辑其实使用递归就可以，当求根节点6的最远距离时先不要求6节点的最远距离，而是先去求它的左子树和右子树的最远距离，这样子不断递归，最终先求出最远距离的肯定会是叶子节点，然后将每个节点的高度都返回给该节点的父亲。这样等于遍历一遍就可以求出整棵二叉树的最远距离。所以时间复杂度是O(N)。

这道面试题也考虑到了多线程的问题，因为这个maxlen我们需要不断的更新，所以可能会有很多人考虑使用全局变量，但是使用全局变量，我们就需要考虑到在多线程环境下，要使得线程安全的话，可能需要加锁，为了简化问题，既然全局变量会引起线程安全问题，那么就不要使用全局变量，而是使用局部变量，我们都知道，每个线程都会有自己的私有栈空间，那么每个线程看见的maxlen就不是同一个，这样就使得该函数是一个可重入函数。

template<class T>
class BinaryTree
{
public:

    template<class T>
    struct BinaryTreeNode
    {
        BinaryTreeNode* _left;
        BinaryTreeNode* _right;
        T _val;
        BinaryTreeNode(const T& val)
            :_left(NULL)
            , _right(NULL)
            , _val(val)
        {}
        BinaryTreeNode()
            :_left(NULL)
            , _right(NULL)
        {}
    };

    typedef BinaryTreeNode<T> Node;

    BinaryTree()
        :_root(NULL)
    {}
//时间复杂度是O(N)
    size_t FindMaxLen()//不断更新最远距离
    {
        //这里的Maxlen考虑到线程安全的问题，也就是使得下面调用的函数是可重入的（所有将Maxlen给成临时变量而不是全局变量）
        size_t MaxLen = 0;
        _FindMaxLen(_root, MaxLen);
        return MaxLen;
    }
private:
    size_t _FindMaxLen(Node* root, size_t& Maxlen)
    {
        if (root->_left)
            _FindMaxLen(root->_left, Maxlen);
        if (root->_right)
            _FindMaxLen(root->_right, Maxlen);


        size_t leftlen = 0, rightlen = 0;
            leftlen = _Height(root->_left);
            rightlen = _Height(root->_right);
        if (leftlen + rightlen > Maxlen)
        {
            Maxlen = leftlen + rightlen;
        }
        return leftlen > rightlen ? leftlen + 1 : rightlen + 1;
    }

    size_t _Height(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        size_t leftlen = 0, rightlen = 0;
        if (root->_left)
         leftlen = _Height(root->_left);
        if (root->_right)
         rightlen = _Height(root->_right);
        return leftlen > rightlen ? leftlen + 1 : rightlen + 1;
    }

    Node* _root;
};

4. 由前序遍历和中序遍历重建二叉树（前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6 5）

这里写图片描述


template<class T>
class BinaryTree
{
public:

    template<class T>
    struct BinaryTreeNode
    {
        BinaryTreeNode* _left;
        BinaryTreeNode* _right;
        T _val;
        BinaryTreeNode(const T& val)
            :_left(NULL)
            , _right(NULL)
            , _val(val)
        {}
        BinaryTreeNode()
            :_left(NULL)
            , _right(NULL)
        {}
    };

    typedef BinaryTreeNode<T> Node;

    BinaryTree()
        :_root(NULL)
    {}
Node* ReBulidTree(char* pre, char* In, size_t len)
    {
        if (pre == NULL || In == NULL || len <= 0)
        {
            return NULL;
        }
        return _ReBulidTree(pre, In, In + len);//两段区间都是闭区间;
    }

private:
    Node* _ReBulidTree(char*& prev,char* In,char* InEnd)
    {
        if (*prev == '\0')//说明子二叉树已经创建成功了
        {
            return NULL;
        }
        Node* newRoot = new Node(*prev);//有两种情况：1.是叶子节点 2.不是叶子节点
        //1.是叶子节点
        if (In == InEnd)
        {
            return newRoot;
        }
        //2.不是叶子节点,这时就可以确定左右子树的区间了
        char* pos = In;
        while (pos != InEnd)
        {
            if (*pos == *prev)
            {
                break;//说明已经找到根节点了
            }
            pos++;
        }
        //这里的pos一定不能等于InEnd
        assert(pos <= InEnd);
        //左右子树可以利用递归去解决
        newRoot->_left = _ReBulidTree(++prev,In, pos - 1);
        newRoot->_right = _ReBulidTree(++prev,pos + 1, InEnd);
        return newRoot;
    }

    Node* _root;
};

最近做剑指offer上的这道题时，发现了一种逻辑更清晰的做法：

#include <algorithm>
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin)
    {
        if(pre.empty())
            {
            return NULL;
        }
        TreeNode* newRoot = new TreeNode(pre[0]);
        vector<int>::iterator it;
        it =find(vin.begin(),vin.end(),pre[0]);
        int leftNum = 0;//统 计左子树中节点的个数
        if(it != vin.end())
            {
            leftNum = it - vin.begin();
        }else
            {
            return NULL;
        }
        //pre(begin+ 1,begin + 1 + leftNum)--》去掉头结点（第一个节点）    vin(begin,begin + leftNum) 
        //pre(begin + 1 + leftNum,end);   in(begin + 1 + leftNum,end)//去掉头结点，头结点在中间
        newRoot->left = reConstructBinaryTree(vector<int> (pre.begin() + 1,pre.begin() + leftNum + 1),vector<int>(vin.begin(),vin.begin() + leftNum));
        newRoot->right = reConstructBinaryTree(vector<int>(pre.begin() + leftNum + 1,pre.end()),vector<int>(vin.begin() + leftNum + 1,vin.end()));
        return newRoot;
    }
};

5.判断一棵树是否是完全二叉树

思路：

这里写图片描述

需要设定一个标记位来标记一个节点有没有孩子节点。

注意以下几点：
1.将每一个节点没有左孩子或右孩子归为一种情况，不要分开进行分析，分开的话容易搞混
2.只要有一个节点有孩子节点那么就判断标志位是否为false，如果为false，那么就说明该节点前面有节点没有左孩子或者右孩子，不符合完全二叉树的特定，这时就可以得出结论：不是完全二叉树，就不必向下继续遍历，如果是true的话，说明该节点前面的所有节点的左右孩子节点都存在，那就按照前面的方法继续向后判断。

bool IsCompleteBinaryTree(Node* _root)
    {
        queue<Node*>  q;
        q.push(_root);
        bool tag = true;
        while (!q.empty())
        {
            Node* front = q.front();
            q.pop();
            if (front->_left)
            {
                if (tag == false)
                {
                    return false;
                }
                q.push(front->_left);
            }
            else
            {
                tag = false;
            }
            if (front->_right)
            {
                if (tag == false)
                {
                    return false;
                }
                q.push(front->_right);
            }
            else
            {
                tag = false;
            }
        }
        return true;
    }

6. 求二叉树的镜像【y】

这里写图片描述

这个问题用递归解决其实很简单，不断递归交换一个根节点的左右子树即可。

void  _Mirror(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        swap(root->_left, root->_right);
        _Mirror(root->_left);
        _Mirror(root->_right);
    }

7.将二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

利用的是二叉搜索树的线索化。
left相当于是prev，right相当于是next。


template<class T>
class BinaryTree
{
public:

    template<class T>
    struct BinaryTreeNode
    {
        BinaryTreeNode* _left;
        BinaryTreeNode* _right;
        T _val;
        BinaryTreeNode(const T& val)
            :_left(NULL)
            , _right(NULL)
            , _val(val)
        {}
        BinaryTreeNode()
            :_left(NULL)
            , _right(NULL)
        {}
    };

typedef BinaryTreeNode<T> Node;
BinaryTree()
        :_root(NULL)
    {}
//转换为双向链表
    Node* ToDuplexingList()
    {
        Node* prev = NULL;
        _ToDuplexingList(_root,prev);
        Node* cur = _root;
        while (cur->_left)
        {
            cur = cur->_left;
        }
        return cur;//返回单链表的头
    }

private:
    void _ToDuplexingList(Node* cur, Node*& prev)
    {
        if (cur == NULL)
        {
            return ;
        }
        _ToDuplexingList(cur->_left, prev);
        cur->_left = prev;
        if (prev)
        {
            prev->_right = cur;
        }
        prev = cur;
        _ToDuplexingList(cur->_right, prev);
    }

    Node* _root;
};
小葱1024
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于二叉树的面试题
文摘资讯
03-28 319
我之前面试了好几家公司，都会考一些关于二叉树的面试题，比如下面这几个面试题：1. 二叉树有哪几种遍历方式2.不用递归如何遍历二叉树3.如何判断二叉树是对...
二叉树面试题
08-28
以下是一些关于二叉树的常见面试题及解题思路： 1. **定义与基本术语**： - 二叉树是每个节点最多有两个子节点的树结构，通常分为左子节点和右子节点。 - 节点包含一个值，可能有零个、一个或两个子节点。 - ...
二叉树中常见的面试题
飞翔的熊blabla
07-08 503
1用一个函数判断一棵树是否平衡 题目：实现一个函数检查一棵树是否平衡。对于这个问题而言， 平衡指的是这棵树任意两个叶子结点到根结点的距离之差不大于1。 注意，对于这道题，要审清题意。它并不是让你判断一棵树是否为平衡二叉树。平衡二叉树的定义为：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1， 并且左右两个子树都是一棵平衡二叉树。 而本题的平衡指的是这棵树任意两个叶子结点到根结点的距离之差不大于1。（程序员面试金典） 思路： 对于本题，只需要求出离根结点最近和最远的叶子结点， 然后看它们到根结.
【数据结构】二叉树常见面试题
如风逝去
08-07 6059
1、创建二叉树 树的结构如下： 这里我们创建二叉树用的是静态创建即不是每次从标准输入读入数据然后插入树中，而是将定义好的一个序列，也就是一个数组构建一棵树，这里采用的是递归创建，首先来看一下参数，首先传进来的就是根结点，然后是要构建树的序列然后是数组下标索引，负责遍历整个数组，然后是数组的大小，然后是无效值，遇到无效值表示当前结点为空，就返回上一层函数调用，递归程序的出口是index...
二叉树习题汇总
最新发布
qq_74336191的博客
05-08 793
所以，其实这道题和相同的树有点类似，都是先比较根节点，再比较根节点的左右子树。对称二叉树是左子树和右子树进行比较， 左子树的左子树与右子树的右子树进行比较，以及左子树的右子树与右子树的左子树进行比较。可以通过比较根节点的左右子节点是否相等，以及递归地比较左子树的左子节点与右子树的右子节点，左子树的右子节点与右子树的左子节点，来判断二叉树是否对称。今天我们学习了7道二叉树的练习题，说句心里话，第一次我做题的时候，也是迷迷糊糊，磕磕碰碰，但是多做几遍，多画一画图，我相信，小伙伴们都能学会~Ready Go!
【数据结构】这些二叉树经典面试题帮你快速入门二叉树
Living_Amethyst的博客
06-27 1413
二叉树入门到精通
轻松搞定面试中的二叉树题目
热门推荐
计算机的艺术
08-29 26万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7518888 树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树是递归定义的，因此，与二叉树有关
二叉树面试题 树和二叉树总结.doc
02-24
"二叉树面试题 树和二叉树总结" 本资源摘要信息涵盖了树和二叉树的面试题总结，包括选择题和解释。涵盖的知识点包括树和二叉树的定义、性质、操作和应用等。 一、树和二叉树的定义 树是一种数据结构，由一个根...
leetcode上的题是谁出的-binary_tree:综合二叉树面试题
06-30
leetcode上的题是谁出的二叉树拼图和面试题 许多“当今的编程难题”或“开发工作面试问题”都与二叉树有关。 这个 repo 包含一个 Go 包中的二叉树实现，以及解决当天难题或问题的代码。 我确实有其他二叉树存储库来...
常见的二叉树面试题大汇总（涵盖二叉搜索树）
09-05
三、常见面试题 1. 判断是否为二叉搜索树：通过递归或迭代遍历所有节点，验证每个节点的值是否满足二叉搜索树的条件。 2. 二叉树的深度：通过递归计算从根节点到叶子节点的最大路径长度。 3. 平衡二叉树：如AVL树...
【面试题8】二叉树的下一个节点
01-06
Python解法 思路：脑中构造出一个树。 1.左子树为父节点； 2.如果一个节点有右子树，下一个节点为右子树的最左结点； 3.如果一个节点无右子树，且为父节点的左子结点，下一个节点为父节点； 4.如果为父节点的右子...
c++ 面试题.zip
01-20
深入理解各种数据结构，如链表、队列、栈、树（二叉树、红黑树等）、图等，以及与之相关的操作（如查找、排序、插入和删除），是C++开发者的基础功。这些知识在解决复杂问题和优化算法效率时尤其关键。 五、操作...
C#面试题整理.zip
01-20
8. **数据结构与算法**：面试题可能会包括链表、树（二叉树、平衡树如AVL、红黑树等）、图、堆、哈希表等数据结构的操作和算法应用（如排序算法、查找算法、动态规划等）。 9. **并发与多线程**：C++11引入了多线程...
面试题68 – II. 二叉树的最近公共祖先
01-06
面试题68 – II. 二叉树的最近公共祖先 【简单题】【递归】 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个...
100道MySql面试题
02-21
MySQL 面试题知识点总结 MySQL 索引使用注意事项可以从三个维度回答： 1. 索引哪些情况会失效： - 查询条件包含 or - 字段类型是字符串，where 时一定用引号括起来，否则索引失效 - like 通配符可能导致索引...
python工程师面试题汇总
11-26
【Python工程师面试题汇总】 面试是评估候选人在Python编程领域技能的重要环节，涵盖基础到高级的知识点。以下是一些常见的Python面试题目及其相关的知识点： ### Python基础知识面试 1. **Python语法特性**：...
平衡二叉树详解 通俗易懂
半亩方糖
01-10 12万+
平衡二叉树（AVL） 阅读之前请先了解 二叉搜索树 平衡二叉树定义：任意节点的子树的高度差都小于等于 1 1. 为什么使用「平衡二叉树」 二叉树能提高查询的效率 O(logn)，但是当你插入 {1,2,3,4,5,6} 这种数据的时候，你的二叉树就像一个「链表」一样，搜索效率变为 O(n) 于是在 1962 年，一个姓 AV 的大佬（G. M. Adelson-Velsky） 和一个姓 L 的大佬（ Evgenii Landis）提出「平衡二叉树」（AVL） 。 于是插入 {1,2,3,4,5,6}
二叉树操作（面试必备）
半壶老酒
03-27 805
本篇针对面试中常见的二叉树操作作个总结：   （1）前序遍历，中序遍历，后序遍历；   （2）层次遍历；   （3）求树的节点数；   （4）求树的叶子数；   （5）求树的深度；   （6）求二叉树第k层的节点个数;   （7）判断两棵二叉树是否结构相同；   （8）求二叉树的镜像；   （9）求两个节点的最低公共祖先节点；   （10）求任意两节点距离；   （11）找出二
数据结构——二叉树相关练习题
＃两个西柚
08-12 9767
一、单项选择题 1.下列关于二叉树的说法中，正确的是( )。 A.度为2的有序树就是二叉树 B.含有n个结点的二叉树的高度为Llog2n┘+ 1 C.在完全二叉树中，若一个结点没有左孩子，则它必是叶结点 D.在任意一棵非空二叉排序树中，删除某结点后又将其插入，则所得二叉排序树与删除前原二叉排序树相同 2.以下说法中，正确的是( )。 A.在完全二叉树中，叶子结点的双亲的左兄弟(若存在)一定不是叶子结点 B.任何一棵二叉树，叶子结点个数为度为2的结点数减1，即n0=n2- 1 C.完全二叉树不适合顺序存储结构
python二叉树面试题
08-31
Python二叉树面试题有很多种，以下是其中几个常见的面试题： 1. 二叉树的最大深度：这个问题要求计算给定二叉树的最大深度。可以使用递归的方法来解决，递归函数的定义是返回当前节点的深度，递归终止条件是节点为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值