二叉树的基本操作及部分面试题

最新推荐文章于 2024-10-14 10:45:00 发布
最新推荐文章于 2024-10-14 10:45:00 发布
阅读量293 收藏
点赞数
分类专栏： 数据结构 C++ 文章标签： 二叉树 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hm108106/article/details/71333807
版权
本文详细介绍了二叉树的各种操作，包括构造、遍历、节点查找等，并提供了递归和非递归两种实现方式。此外，还介绍了如何通过前序和中序遍历来重建二叉树、计算树的深度及节点数量、寻找公共祖先等问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.构造二叉树

#include<iostream>
#include<queue>
#include<stack>
#include<assert.h>
using namespace std;

template<class T>
struct BinaryTreeNode
{
    T _value;
    BinaryTreeNode<T>* _pLeft;//左孩子
    BinaryTreeNode<T>* _pRight;//右孩子

    BinaryTreeNode(const T& value)
        :_value(value)
        ,_pLeft(NULL)
        ,_pRight(NULL)
    {}
};

template<class T>
class BinaryTree
{
public:
    typedef BinaryTreeNode<T> Node;
    BinaryTree()
        :_pRoot(NULL)
    {}
    BinaryTree(const T array[],size_t size,const T& invalid)//构造函数
    {
        size_t index=0;
        _CreateBinaryTree(_pRoot,array,size,index,invalid);
    }
    BinaryTree(const BinaryTree<T>& bt)//拷贝构造函数
    {
        _pRoot=_CopyBinaryTree(bt._pRoot);
    }
    ~BinaryTree()
    {
        _DestroyBinaryTree(_pRoot);
    }
    BinaryTree<T>& operator=(const BinaryTree<T>& bt)
    {
        if(this!=&bt)
        {
            __DestroyBinaryTree(_pRoot);
            _pRoot=_CopyBinaryTree(bt._pRoot);
        }
        return *this;
    }
private:
    void _CreateBinaryTree(Node* &pRoot,const T array[],size_t size,size_t& index,const T& invalid)
    {
        if(index<size&&invalid!=array[index])
        {
            pRoot=new Node(array[index]);
            _CreateBinaryTree(pRoot->_pLeft,array,size,++index,invalid);//创建左子树
            _CreateBinaryTree(pRoot->_pRight,array,size,++index,invalid);//创建右子树
        }
    }
    Node* _CopyBinaryTree(Node* pRoot)//拷贝
    {
        Node* pNewRoot=NULL;
        if(pRoot)
        {
            //拷贝根节点
            pNewRoot=new Node(pRoot->_value);
            //拷贝左子树
            pNewRoot->_pLeft=_CopyBinaryTree(pRoot->_pLeft);
            //拷贝右子树
            pNewRoot->_pRight=_CopyBinaryTree(pRoot->_pRight);
        }
        return pNewRoot;
    }
    void _DestroyBinaryTree(Node* &pRoot)
    {
        if(pRoot)
        {
            _DestroyBinaryTree(pRoot->_pLeft);
            _DestroyBinaryTree(pRoot->_pRight);
            delete pRoot;
            pRoot=NULL;
        }
    }
private:
    Node* _pRoot;
};

2.二叉树的遍历—递归形式

public:
     void PreOrder()//前序遍历(递归)--接口 
    {
        cout<<"PreOrder:"<<endl;
        _PreOrder(_pRoot);
        cout<<endl;
    }
    void InOrder()//中序遍历(递归)---接口
    {
        cout<<"InOrder:"<<endl;
        _InOrder(_pRoot);
        cout<<endl;
    }
    void PostOrder()//后序遍历(递归)---接口
    {
        cout<<"PostOrder:"<<endl;
        _PostOrder(_pRoot);
        cout<<endl;
    }

    void LevelOrder()//层序遍历
    {
        if(NULL==_pRoot)
            return;
        queue<Node*> q;
        q.push(_pRoot);
        cout<<"LevelOrder:"<<endl;
        while(!q.empty())//队列不为空
        {
            Node* pCur=q.front();//取队头元素
            if(pCur->_pLeft)
                q.push(pCur->_pLeft);//取左子树
            if(pCur->_pRight)
                q.push(pCur->_pRight);//取右子树
            cout<<pCur->_value<<" ";//访问队头
            q.pop();//出队列
        }
        cout<<endl;
    }
private:
    void _PreOrder(Node* pRoot)//前序遍历(递归)
    {
        if(pRoot)
        {
            cout<<pRoot->_value<<" ";
            _PreOrder(pRoot->_pLeft);
            _PreOrder(pRoot->_pRight);
        }
    }

    void _InOrder(Node* pRoot)//中序遍历(递归)
    {
        if(pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout<<pRoot->_value<<" ";
            _InOrder(pRoot->_pRight);
        }
    }
    void _PostOrder(Node* pRoot)//后序遍历(递归)
    {
        if(pRoot)
        {   
            _PostOrder(pRoot->_pLeft);
            _PostOrder(pRoot->_pRight);
            cout<<pRoot->_value<<" ";
        }
    }

3.二叉树的遍历—-非递归形式

public:
    void _PreOrder_Nor()//前序遍历(非递归)---方法一
    {
        if(NULL==_pRoot)
            return;
        stack<Node*> s;
        s.push(_pRoot);
        while(!s.empty())
        {
            Node* pTop=s.top();
            cout<<pTop->_value<<" ";
            s.pop();
            if(pTop->_pRight)
                s.push(pTop->_pRight);
            if(pTop->_pLeft)
                s.push(pTop->_pLeft);
        }
        cout<<endl;
    }
    void _PreOrder_Nor()//前序遍历(非递归)---方法二:左右结点都存在时，将右结点入栈，直接访问左结点
    {
        if(NULL==_pRoot)
            return;
        stack<Node*> s;
        s.push(_pRoot);
        while(!s.empty())
        {
            Node* pCur=s.top();
            s.pop();
            while(pCur)
            {
                cout<<pCur->_value<<" ";
                if(pCur->_pRight)
                    s.push(pCur->_pRight);
                pCur=pCur->_pLeft;
            }
        }
        cout<<endl;
    }

    void _InOrder_Nor()//中序遍历(非递归)
    {
        if(NULL==_pRoot)
            return;
        stack<Node*> s;
        Node* pCur=_pRoot;
        while(pCur||!s.empty())
        {
            while(pCur)//找最左边的结点，并保存路径上的每个结点
            {
                s.push(pCur);
                pCur=pCur->_pLeft;
            }
            pCur=s.top();
            cout<<pCur->_value<<" ";
            s.pop();
            while(NULL==pCur->_pRight && !s.empty())//右子树不存在时
            {
                pCur=s.top();
                cout<<pCur->_value<<" ";
                s.pop();
            }
            pCur=pCur->_pRight;
        }
        cout<<endl;
    }

    void _PostOrder_Nor()//后序遍历(非递归)
    {
        if(NULL==_pRoot)
            return;
        stack<Node*> s;
        Node* pCur=_pRoot;
        Node* prev=NULL;
        while(pCur||!s.empty())
        {
            while(pCur)//找最左边的结点，并保存路径上的每个结点
            {
                s.push(pCur);
                pCur=pCur->_pLeft;
            }
            Node* pTop=s.top();
            if(NULL==pTop->_pRight||prev==pTop->_pRight)//右子树存在时，可能会被访问两次，造成死循环，所以要判断是否已经访问过
            {
                cout<<pTop->_value<<" ";
                prev=pTop;
                s.pop();
            }
            else
                pCur=pTop->_pRight;
        }
        cout<<endl;
    }

4.找二叉树中是否有某个节点

public:
     Node* Find(const T& value)//找二叉树中某个结点
    {

        Node* pCur=NULL;
        pCur=_Find(_pRoot,value);
        cout<<pCur->_value<<endl;
        return pCur;
    }
private:
    Node* _Find(Node* pRoot,const T& value)//根据值寻找二叉树中的相应结点
    {
        if(NULL==pRoot)
            return NULL;
        if(pRoot->_value==value)
            return pRoot;   
        Node* pCur=NULL;
        if(pCur=_Find(pRoot->_pLeft,value))
            return pCur;
        return _Find(pRoot->_pRight,value);

    }

4.获取双亲节点

public：
     Node* Parent(Node* pCur)//寻找双亲结点
    {
        Node* result=NULL;
        result=_Parent(_pRoot,pCur);
        cout<<"Parent:"<<endl;
        cout<<result->_value<<endl;
        return result;
    }  
private：
    Node* _Parent(Node* pRoot,Node* pCur)//获取双亲,pRoot为根节点 
    {
        assert(pCur);
        if(pRoot==NULL||pCur==pRoot)
            return NULL;
        if((pCur==pRoot->_pLeft)||(pCur==pRoot->_pRight))
            return pRoot;
        Node* ret=NULL;
        if(ret=_Parent(pRoot->_pLeft,pCur))
            return ret;
        else
            return _Parent(pRoot->_pRight,pCur);
    }

5.获取左孩子节点

public:
     Node* LeftChild(Node* pCur)//寻找左孩子结点
    {
        Node* result=NULL;
        result=_LeftChild(_pRoot,pCur);
        cout<<"LeftChild:"<<endl;
        cout<<result->_value<<endl;
        return result;
    }
private：
     Node* _LeftChild(Node* pRoot,Node* pCur)
    {
        assert(pCur);
        if(pRoot!=NULL && pCur->_pLeft!=NULL)
            return pCur->_pLeft;
        Node* ret=NULL;
        if(ret=_LeftChild(pRoot->_pLeft,pCur))
            return ret;
        else
            return _LeftChild(pRoot->_pRight,pCur);

    }

6.获取右孩子节点

public:
     Node* RightChild(Node* pCur)//寻找右孩子结点
    {
        Node* result=NULL;
        result=_RightChild(_pRoot,pCur);
        cout<<"RightChild:"<<endl;
        cout<<result->_value<<endl;
        return result;
    }
private：
     Node* _RightChild(Node* pRoot,Node* pCur)
    {
        assert(pCur);
        if(pRoot!=NULL && pCur->_pRight!=NULL)
            return pCur->_pRight;
        Node* ret=NULL;
        if(ret=_RightChild(pRoot->_pLeft,pCur))
            return ret;
        else
            return _RightChild(pRoot->_pRight,pCur);

    }

7.计算二叉树的深度

public:
     size_t Height()//计算二叉树的深度
    {
        size_t depth=0;
        depth=_Height(_pRoot);
        cout<<"Height:"<<depth<<endl;      
        return depth;
    }
private：
     size_t _Height(Node* pRoot)//计算二叉树的深度
    {
        int hl=0;
        int hr=0;
        int max=0;
        if(pRoot!=NULL)
        {
            hl=_Height(pRoot->_pLeft);
            hr=_Height(pRoot->_pRight);
            max=hl>hr?hl:hr;
            return max+1;
        }
        else
            return 0;
    }

8.计算二叉树的叶子节点个数

public:
     size_t GetLeefCount()//计算叶子结点个数
    {
        size_t count=0;
        count=_GetLeefCount(_pRoot);
        cout<<"leefcount: "<<count<<endl;       
        return count;
    }
privte:
     size_t _GetLeefCount(Node* pRoot)//计算叶子结点个数
    {
        if(pRoot==NULL)
            return 0;
        if(NULL==pRoot->_pLeft && NULL==pRoot->_pRight)
            return 1;
        return _GetLeefCount(pRoot->_pLeft)+_GetLeefCount(pRoot->_pRight);
    }

9.计算二叉树第k层的节点个数

public:
     size_t GetKLevelCount(size_t k)//计算二叉树第k层结点数
    {
        size_t count=0;
        count=_GetKLevelCount(_pRoot, k);
        cout<<"KLevelCount: "<<count<<endl;       
        return count;
    }
private：
     size_t _GetKLevelCount(Node* pRoot,size_t k)//计算二叉树的第K层节点数
    {
        if(pRoot==NULL||k<1)
            return 0;
        if(k==1)
            return 1;
        return _GetKLevelCount(pRoot->_pLeft,k-1)+_GetKLevelCount(pRoot->_pRight,k-1);
    }

10.求二叉树的镜像树—-递归形式

public:
     void BinaryMirror()//求镜像树(递归)
    {
        _BinaryMirror(_pRoot);
    }
private:
     void _BinaryMirror(Node* pRoot)//镜像树(递归)
    {
        if(pRoot)
        {
            std::swap(pRoot->_pLeft,pRoot->_pRight);
            _BinaryMirror(pRoot->_pLeft);
            _BinaryMirror(pRoot->_pRight);
        }
    }

11.求二叉树的镜像树—-非递归形式

public:
     void BinaryMirror_Nor()//求镜像树(非递归)
    {
        if(NULL==_pRoot)
            return;
        queue<Node*> q;
        q.push(_pRoot);
        while(!q.empty())
        {
            Node* pCur=q.front();
            if(pCur->_pLeft)
                q.push(pCur->_pLeft);
            if(pCur->_pRight)
                q.push(pCur->_pRight);
            std::swap(pCur->_pLeft,pCur->_pRight);
            q.pop();
        }
    }

12.判断是否为完全二叉树

public：
    bool IsCompleteBinaryTree()//判断是否为完全二叉树?
    {
        if(NULL==_pRoot)
            return true;
        bool flag=false;
        queue<Node*> q;
        q.push(_pRoot);
        while(!q.empty())
        {
            Node* pCur=q.front();
            if(flag)//判断到此处时，说明pCur已经指向一棵右子树
            {
                if(pCur->_pLeft||pCur->_pRight)
                    return false;
            }   
            if(pCur->_pLeft && pCur->_pRight)
            {
                q.push(pCur->_pLeft);
                q.push(pCur->_pRight);
            }
            else if(pCur->_pLeft)
            {
                q.push(pCur->_pLeft);
                flag=true;
            }
            else if(pCur->_pRight)
                return false;
            else
                flag=true;                                  
            q.pop();
        }
        return true;
    }

13.根据前序遍历和中序遍历的结果重建二叉树

public:
    Node* ReBuild_PreIn(T Pre[],int start_Pre,int end_Pre,T In[],int start_In,int end_In)//根据前序遍历和中序遍历的结果重建二叉树
    {
        if((end_Pre-start_Pre)!=(end_In-start_In)||start_Pre>end_Pre)
            return NULL;
        Node* pCur=new Node(sizeof(Pre));
        pCur->_value=Pre[start_Pre];
        pCur->_pLeft=NULL;
        pCur->_pRight=NULL;
        if(start_Pre==end_Pre)
            return pCur;
        int index=0;
        int length=0;
        for(index=start_In;index<=end_In;index++)
        {
            if(In[index]==Pre[start_Pre])
                break;
        }
        if(index>end_In)
            return NULL;
        if (index > start_In)    
        {   
            length = index-start_In;   
            pCur->_pLeft= ReBuild_PreIn(Pre,start_Pre+1,start_Pre+1+length-1,In,start_In,start_In+length-1);   
        }   
         //有右子树，递归调用构建右子树   
        if (index < end_In)    
        {   
            length = end_In - index;   
            pCur->_pRight= ReBuild_PreIn(Pre,end_Pre-length+1,end_Pre,In,end_In-length+1,end_In);   
        }   
        return pCur;
    }

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

public:
    void CommonAncestor(Node* node1,Node* node2)
    {
        //bool flag=false;
        cout<<(_CommonAncestor(_pRoot,node1,node2))->_value<<endl;
    }
private：
    bool _GetPath(Node* pRoot,Node* pCur,stack<Node*>& s)//在根为pRoot的树中查找节点pCur的路径
    {
        if (NULL == pRoot || NULL == pCur)//树为空
            return false;
        s.push(pRoot);    //将当前节点入栈

        if (pCur->_value == pRoot->_value)  //找到路径
        {
              return true;
        }
        if (_GetPath(pRoot->_pLeft,pCur,s))//在左子树中找路径
        {
            return true;
        }
        if (_GetPath(pRoot->_pRight,pCur,s))//在右子树中找路径
        {
            return true;
        }
        s.pop();
        return false;
    }
    Node* _CommonAncestor(Node*& pRoot,Node* n1,Node* n2)//求两个节点的最近公共祖先(时间复杂度：O(N))
    {
        //树为空
        if (NULL == pRoot)
        {
            return NULL;
        }
        stack<Node*> s1;
        stack<Node*> s2;
        //用栈s1和s2分别保存节点n1和节点n2的路径
        _GetPath(pRoot,n1,s1);
        _GetPath(pRoot,n2,s2);
        //将多余的路径删除
        while (s1.size() > s2.size())
        {
            s1.pop();
        }
        while(s1.size() < s2.size())
        {
            s2.pop();
        }
         //找s1与s2中不同的节点
        while(s1.top() != s2.top())
        {
            s1.pop();
            s2.pop();
        }
        return s1.top();
    }

15.测试代码：

void Test()
{
    char* pStr="124###35##6";
    char* pStrs="124##5##3";
    char* PreOrder="124356";
    char* InOrder="421536";
    BinaryTree<char> bt1(pStr,strlen(pStr),'#');
    BinaryTree<char> bts(pStrs,strlen(pStrs),'#');
    //bt1.ReBuild_PreIn(PreOrder,0,5,InOrder,0,5);
    bt1.CommonAncestor(bt1.Find('5'),bt1.Find('6'));

    //bt1.PreOrder();
    //bt1.InOrder();
    //bt1.PostOrder();
    //bt1.LevelOrder();
    //bt1.Find('5');
    //bt1.Parent(bt1.Find('5'));
    //bt1.LeftChild(bt1.Find('1'));
    //bt1.RightChild(bt1.Find('1'));
    //bt1.Height();
    //bt1.GetLeefCount();
    //bt1.GetKLevelCount(4);
    //bt1.BinaryMirror_Nor();
    //bt1.BinaryMirror();   
    //bt1._PreOrder_Nor();
    //bt1._InOrder_Nor();
    //bt1._PostOrder_Nor();
    //cout<<bts.IsCompleteBinaryTree()<<endl;

    /*cout<<endl;

    BinaryTree<char> bt2(bt1);
    bt2.PreOrder();
    bt2.InOrder();
    bt2.PostOrder();
    cout<<endl;

    BinaryTree<char> bt3=bt1;
    bt3.PreOrder();
    bt3.InOrder();
    bt3.PostOrder();*/
}

int main()
{
    Test();
    return 0;
}
二叉树经典面试题
qq_38936579的博客
08-14 552
二叉树的结点类型如下： typedef struct BtNode { BtNode *leftchild; BtNode *rightchild; ElemType data; }BtNode, *BinaryTree; 1. 给你一颗普通的二叉树，求二叉树中最远的两个节点的距离    分析：    1、如果具有最远距离的两个结点之间的路径经过根结点，则最远距离...
数据结构 - 二叉树 - 面试中常见的二叉树算法题
热门推荐
从零开始
01-17 2万+
数据结构 - 二叉树 - 面试中常见的二叉树算法题 数据结构是面试中必定考查的知识点，面试者需要掌握几种经典的数据结构：线性表（数组、链表）、栈与队列、树（二叉树、二叉查找树、平衡二叉树、红黑树）、图。 本文主要介绍树中的常见的二叉树数据结构。包括 概念简介 二叉树中树节点的数据结构（Java） 二叉树的遍历（Java） 常见的二叉树算法题（Java） 概念简介 如果对二叉
C++ 二叉树的基本操作
不断的谦逊，不断的努力
04-02 1167
<br />C++实现二叉树的基本操作<br />包括 添加节点、删除节点、前序遍历、中序遍历、后续遍历、层序遍历、最大值、最小值、二叉树的高度<br /> <br />//Tree.h 头文件<br />#include <stdio.h><br /> <br />class Tree<br />{<br /> private :<br />  //节点元素类型为结构体<br />   struct LinkNode<br />   {<br />   int data;<br />   LinkNode
二叉树相关面试题目总结
一步一脚印
07-19 5978
前言： 一、为什么要树结构？ 不像数组、链表是线性的数据结构，树是一种分层的非线性数据结构 （1）使用树的一个原因是：我们需要存储有分层关系的信息（比如说文件系统） （2）另外一个是（BST）：当把树建成有一定的形式的树可以方便数据的查找（对于平衡的树，查找时间复杂度为O（logn））。 （3）同理对于这样一个树（AVL/红黑树）：他们的插入和删除的时间复杂度是（O（logn）） （4
【数据结构】这些二叉树经典面试题帮你快速入门二叉树
Living_Amethyst的博客
06-27 1819
二叉树入门到精通
java(二叉树的基本操作和部分二叉树相关的题)
最新发布
12-26
除了基本操作，二叉树在算法竞赛和面试中也常作为考察点出现。例如，经常需要根据题目要求构造特定形状的二叉树，或者在给定的二叉树上进行各种变换和计算。这些问题往往需要深入理解二叉树的性质和相关算法，通过...
二叉树面试题 树和二叉树总结.doc
02-24
"二叉树面试题 树和二叉树总结" 本资源摘要信息涵盖了树和二叉树的面试题总结，包括选择题和解释。涵盖的知识点包括树和二叉树的定义、性质、操作和应用等。 一、树和二叉树的定义 树是一种数据结构，由一个根...
Java数据结构二叉树面试题精华(画图详解)
多敲代码防脱发的博客
10-14 2377
针对二叉树，因为涉及到递归，需要跟多的练习强化递归的思想，其中也包括需要画图理解一些想不通的问题来提升自己！一下面这些题为例，一起来提升自己的逻辑思维能力！(可能其中一些题已经写过，但是希望能再写一遍有助于提高代码能力)
二叉树面试题
08-28
以下是一些关于二叉树的常见面试题及解题思路： 1. **定义与基本术语**： - 二叉树是每个节点最多有两个子节点的树结构，通常分为左子节点和右子节点。 - 节点包含一个值，可能有零个、一个或两个子节点。 - ...
《剑指Offer》刷题笔记——面试题55-II. 平衡二叉树
12-22
《剑指Offer》是针对程序员面试的一本经典书籍，其中的面试题55-II主要讨论的是平衡二叉树。平衡二叉树是一种特殊的二叉树结构，它的左右两个子树的高度差不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树...
【数据结构】二叉树面试题总结(持续更新中...)
weixin_44258092的博客
08-10 1559
总结了二叉树的相关习题。
leetcode二叉树面试题目集锦
xiangxianghehe的博客
08-18 7034
struct BinaryTreeNode { int value; BinaryTreeNode* left; BinaryTreeNode* right; BinaryTreeNode(int x) : value(x), left(NULL), right(NULL) {} }; 初始化 BinaryTreeNode *root = new ...
【二叉树】42 二叉树：层次遍历
windyuan~
02-24 1727
问题描述 : 目的：使用C++模板设计并逐步完善二叉树的抽象数据类型（ADT）。 内容： （1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。 （2）基本操作5：在二叉树的二叉链表存储形式建立的基础上，.
二叉树的五道面试题
LLZK_的博客
11-30 6279
1、判断一棵树是否是完全二叉树； 2、求二叉树中最远两个结点的距离； 3、由前序和中序遍历序列重建二叉树 （前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6 5）； 4、求二叉树两个结点的最近公共祖先； 5、将二叉搜索树转化成有序的双向链表； 判断一棵树是否是完全二叉树 要想判断一颗树是否是完全二叉树，你得先知道什么是完全二叉树。 完全二
二叉树的经典面试题总结
snow_5288的博客
05-04 9183
1、二叉树的构造 2、遍历二叉树 3、求二叉树的高度（深度） 4、求二叉树中节点的个数 5、求二叉树中叶子节点的个数 6、求二叉树第K层的节点个数 7、判断一个节点是否在二叉树中 8、求两个节点的最近公共祖先9、判断一棵二叉树是否是平衡二叉树10、求二叉树中最远的两个节点的距离 11、由前序遍历和中序遍历重建二叉树12、判断一棵树是否是完全二叉树13、求二叉树的镜像14、二叉搜索树->有序双链表
【数据结构】二叉树常见面试题
如风逝去
08-07 6160
1、创建二叉树 树的结构如下： 这里我们创建二叉树用的是静态创建即不是每次从标准输入读入数据然后插入树中，而是将定义好的一个序列，也就是一个数组构建一棵树，这里采用的是递归创建，首先来看一下参数，首先传进来的就是根结点，然后是要构建树的序列然后是数组下标索引，负责遍历整个数组，然后是数组的大小，然后是无效值，遇到无效值表示当前结点为空，就返回上一层函数调用，递归程序的出口是index...
数据结构——二叉树的基本操作（一）
yxl_d的博客
09-26 5683
一、实验目的及要求 1.理解二叉树的基本概念和特点 2.掌握二叉树的链式存储结构 3.掌握二叉树的基本操作 二、实验内容（或实验原理、实验拓扑） 1.实现二叉树的如下操作，二叉树如下图所示。(采用二叉链存储结构实现) (1)输出二叉树b； (2)输出C节点的左、右孩子节点值； (3)输出二叉树的深度； (4)输出二叉树b的节点个数； (5)输出二叉树b的叶子节点个数。 三、实验设计方案（包括实验...
二叉树面试题汇总(一)
11-02 2895
title: 二叉树面试题汇总(一) categories: 数据结构 date: 2016-08-18 9:16:00版权声明：本站采用开放的[知识共享署名-非商业性使用-相同方式共享 许可协议]进行许可所有文章出现的代码，将会出现在我的github中，名字可以根据类全名来找，我在github中的文件夹也会加目录备注。计算二叉树的总结点数树的定义：public class BinaryTree
二叉树的常见笔试面试题
Nessie_zhao的博客
05-16 5041
在二叉树的基本操作里已经说明如何用递归的方法进行二叉树的遍历，那么如何用非递归的方法来进行二叉树的遍历呢，请看下文1.使用非递归方式进行二叉树的先序遍历![这里写图片描述](//img-blog.youkuaiyun.com/20180429152827371?watermark/2/text/Ly9ibG9nLmNzZG4ubmV0L05lc3NpZV96aGFv/font/5a6L5L2T/fontsiz...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值