二叉树的那些事

最新推荐文章于 2022-07-09 13:48:50 发布
最新推荐文章于 2022-07-09 13:48:50 发布
阅读量272 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mffjin/article/details/47907011
版权

二叉树的操作，最近写了这些代码，同时也借鉴了网上前辈的们的经验。有时间再继续完善。创建的问二叉排序树。微笑


#include<iostream>

#include<stack>

#include<vector>

#include<queue>

#include<Windows.h>

using namespacestd;

template<class Type>

class BStree;

int maxlen=0;

intdistancebetweenNode=0;

二叉树节点的定义

template<classType>

class BinaryNode

{

  friend class BStree<Type>;

public:

      BinaryNode():left(NULL),right(NULL){}

      BinaryNode(const Type&value):data(value),left(NULL),right(NULL){}

private:

      Type data;

      BinaryNode *left;

      BinaryNode *right;

      int maxleft;

      int maxright;

      //bool isFirst;

};

template<classType>

class BStree

{

private:

      BinaryNode<Type> *root;

      bool isFirst;

public:

      //int maxlen;

      BStree():root(NULL){}

      BStree(const Type & tree);

      BinaryNode<Type>*GetRoot()const{return root;}

      Type createBitree(const Type & value);

      //==================================================//

      //树的递归遍历

      //=================================================//

      void preOrder(const BinaryNode<Type>*startNode);

      void inOrder(const BinaryNode<Type>*starNode);

      void PostOrder(constBinaryNode<Type>*startNode);

 

      //=================================================//

      //树的非递归遍历

      //===============================================//

      void noRecursivePre(BinaryNode<Type>* startNode);

      void noRecursiveIn(BinaryNode<Type>*startNode);

      voidnoRecursivePost1(BinaryNode<Type>* startNode);

      voidnoRecursivePost2(BinaryNode<Type>* startNode);

      //二叉树中节点的最大距离

      void FindMaxLen(BinaryNode<Type>*startNode);

      //二叉树最低公共节点

      bool findpath(BinaryNode<Type>*startNode,vector<int> &path,int key);

      int findLCA(BinaryNode<Type>*startNode,int key1,int key2);

      //二叉树任意两个节点之间的距离

      voidFindLen(BinaryNode<Type>*startNode,int key1,int key2);

      //二叉树的深度

      inttreeDepth(BinaryNode<Type>*startNode);

      int treeDepthNoRe(BinaryNode<Type>*startNode);

      //二叉树的宽度

      inttreeWidth(BinaryNode<Type>*startNode);

      //判断平衡二叉树

      boolbalanceTree(BinaryNode<Type>*startNode);

     

};

 

创建二叉树

template<classType>

TypeBStree<Type>::createBitree(const Type &value)

{

      if(root==NULL)

      {

             root=new BinaryNode<Type>(value);

      }

      else

      {

             BinaryNode<Type> *node=root;

             while(1)

             {

                    if(value>node->data)

                    {

                           if(node->right==NULL)

                           {

                                  node->right=newBinaryNode<Type>(value);

                                  break;

                           }

                           else

                           {

                                  node=node->right;

                           }

                    }

                    else

                    {

                           if(node->left==NULL)

                           {

                                  node->left=newBinaryNode<Type>(value);

                                  break;

                           }

                           else

                           {

                                  node=node->left;

                           }

                    }

             }

      }

      return value;

}

二叉树线序遍历（递归）

template<classType>

voidBStree<Type>::preOrder(const BinaryNode<Type> *startNode)

{

      if(startNode==NULL)

             return ;

      else

      {

             cout<<startNode->data<<"";

             preOrder(startNode->left);

             preOrder(startNode->right);

 

      }

     

}

二叉树中序遍历（递归）

template<classType>

voidBStree<Type>::inOrder(const BinaryNode<Type>*startNode)

{

      if(startNode==NULL)

             return;

      else

      {

             inOrder(startNode->left);

             cout<<startNode->data<<"";

             inOrder(startNode->right);

      }

}

二叉树后序遍历（递归）

template<classType>

voidBStree<Type>::PostOrder(const BinaryNode<Type>*startNode)

{

      if(startNode==NULL)

             return;

      else

      {

             PostOrder(startNode->left);

             PostOrder(startNode->right);

             cout<<startNode->data<<"";

      }

}

二叉树先序遍历（非递归）

template<classType>

voidBStree<Type>::noRecursivePre( BinaryNode<Type>*startNode)

{

      stack<BinaryNode<Type> *>s;

      BinaryNode<Type>  *p=startNode;

      while(p!=NULL||!s.empty())

      {

             while(p!=NULL)

             {

                    cout<<p->data<<"";

                    s.push(p);

                    p=p->left;

             }

             if(!s.empty())

             {

                    p=s.top();

                    s.pop();

                    p=p->right;

             }

      }

 

}

template<classType>

二叉树中序遍历（非递归）

voidBStree<Type>::noRecursiveIn(BinaryNode<Type>* startNode)

{

      stack<BinaryNode<Type> *>s;

      BinaryNode<Type>*p=startNode;

      while(p!=NULL||!s.empty())

      {

             while(p!=NULL)

             {

                    s.push(p);

                    p=p->left;

             }

             if(!s.empty())

             {

                    p=s.top();

                    s.pop();

                    cout<<p->data<<"";

                    p=p->right;

 

             }

      }

 

}

二叉树后序遍历（非递归）

template<classType>

voidBStree<Type>::noRecursivePost1(BinaryNode<Type>* startNode)

{

      stack<BStree<Type> *>s;

      BinaryNode<Type> *p=startNode;

      BStree<Type>*temp;

      while(p!=NULL||!s.empty())

      {

             while(p!=NULL)

             {

                    BStree<Type>*btn=(BStree *)malloc(sizeof(BStree));

                    btn->root=p;

                    btn->isFirst=true;

                    s.push(btn);

                    p=p->left;

             }

             if(!s.empty())

             {

                    temp=s.top();

                    s.pop();

                    if(temp->isFirst==true)//表示第一次访问

                    {

                           temp->isFirst=false;

                           s.push(temp);

                           p=temp->root->right;

                    }

                    else

                    {

                           cout<<temp->root->data<<"";

                           p=NULL;

                    }

             }

      }

 

 

}

二叉树后序遍历2（非递归）

template<classType>

voidBStree<Type>::noRecursivePost2(BinaryNode<Type>* startNode)

{

      stack<BinaryNode<Type> *>s;

      BinaryNode<Type> *cur;//当前节点

      BinaryNode<Type> *pre=NULL;//前一次被访问的节点

      s.push(startNode);

      while(!s.empty())

      {

             cur=s.top();

             if((cur->left==NULL&&cur->right==NULL)||(pre!=NULL&&(pre==cur->left||pre==cur->right)))

             {

                    cout<<cur->data<<"";

                    s.pop();

                    pre=cur;

             }

             else

             {

                    if(cur->right!=NULL)

                           s.push(cur->right);

                    if(cur->left!=NULL)

                           s.push(cur->left);

             }

      }

}

二叉树而节点之间的最大距离

template<class Type>

voidBStree<Type>::FindMaxLen(BinaryNode<Type>* startNode)

{

      int tmp;

      if(startNode==NULL)return;

    if(startNode->left==NULL)startNode->maxleft=0;

      if(startNode->right==NULL)startNode->maxright=0;

      if(startNode->left!=NULL)

             FindMaxLen(startNode->left);

      if(startNode->right!=NULL)

             FindMaxLen(startNode->right);

      if(startNode->left!=NULL)

      {

             tmp=(startNode->left->maxleft>startNode->left->maxright)?(startNode->left->maxleft):(startNode->left->maxright);

             startNode->maxleft=tmp+1;

      }

      if(startNode->right!=NULL)

      {

             tmp=(startNode->right->maxleft>startNode->right->maxright)?(startNode->right->maxleft):(startNode->right->maxright);

             startNode->maxright=tmp+1;

      }

     

      maxlen=(startNode->maxleft+startNode->maxright)>(maxlen)?(startNode->maxleft+startNode->maxright):maxlen;

 

}

获得遍历序列

template<classType>

boolBStree<Type>::findpath(BinaryNode<Type> *startNode,vector<int>&path, int key)

{

      if(startNode==NULL)return false;

      path.push_back(startNode->data);

      if(startNode->data==key) return true;

      boolfind=(findpath(startNode->left,path,key)||findpath(startNode->right,path,key));

      if(find) return true;

      path.pop_back();

      return false;

}

获得二叉树两个节点之间的最低公共节点

template<classType>

intBStree<Type>::findLCA(BinaryNode<Type>*startNode,int key1,int key2)

{

      vector<int> path1,path2;

      bool find1=findpath(startNode,path1,key1);

      bool find2=findpath(startNode,path2,key2);

      if(find1&&find2)

      {

             int ans;

             for(int i=0;i<path1.size();i++)

             {

                    if(path1[i]!=path2[i])

                           break;

                    else

                           ans=path1[i];

             }

             return ans;

      }

      return -1;

}

template<classType>

voidBStree<Type>::FindLen(BinaryNode<Type>*startNode,int key1,int key2)

{

      vector<int> path1,path2;

      int len=0;

      bool find1=findpath(startNode,path1,key1);

      bool find2=findpath(startNode,path2,key2);

      if(find1&&find2)

      {

             if(path1.size()>=path2.size())

             {

                    len=path1.size()-path2.size();

                    for(int i=path1.size()-len-1,j=path2.size()-1;j>=0&&i>=0;i--,j--)

                    {

                           if(path1[i]!=path2[j])

                                  distancebetweenNode=distancebetweenNode+1;//74 10 1 5 -1 2 9 13 12 11 14 s

                           else

                                  break;

                    }

             }

             else

             {

                    len=path2.size()-path1.size();

            for(inti=path2.size()-len-1,j=path1.size()-1;j>=0&&i>=0;j--,i--)

                    {

                           if(path1[j]!=path2[i])

                                  distancebetweenNode++;

                           else

                                  break;

                    }

             }

 

             distancebetweenNode=2*distancebetweenNode+len;

 

      }

}

二叉树的深度

template<classType>

intBStree<Type>::treeDepth(BinaryNode<Type>*startNode)

{

      if(startNode==NULL)

             return 0;

      returntreeDepth(startNode->left)>treeDepth(startNode->right)?(treeDepth(startNode->left)+1):(treeDepth(startNode->right)+1);

}

二叉树深度非递归

template<classType>

intBStree<Type>::treeDepthNoRe(BinaryNode<Type>*startNode)

{

 

}

二叉树宽度

template<classType>

intBStree<Type>::treeWidth(BinaryNode<Type>*startNode)

{

      if(startNode==NULL)

             return 0;

      int nLastLevelWidth=0;

      int nTempLastLevelWidth;

      int nCurLevelWidth;

      int nWidth=1;

      queue<BinaryNode<Type>*>myqueue;

      myqueue.push(startNode);//将根节点入队

      nLastLevelWidth=1;

      BinaryNode<Type>*pCur=NULL;

      while(!myqueue.empty())

      {

             nTempLastLevelWidth=nLastLevelWidth;

             while(nTempLastLevelWidth!=0)

             {

                    pCur=myqueue.front();//取出队列头元素

                    myqueue.pop();

                    if(pCur->left!=NULL)

                    {

                           myqueue.push(pCur->left);

                    }

                    if(pCur->right!=NULL)

                    {

                           myqueue.push(pCur->right);

                    }

                    nTempLastLevelWidth--;

             }

             nCurLevelWidth=myqueue.size();

             nWidth=nCurLevelWidth>nWidth?nCurLevelWidth:nWidth;

             nLastLevelWidth=nCurLevelWidth;

     

      }

      return nWidth;

}

判断平衡二叉树

template<classType>

boolBStree<Type>::balanceTree(BinaryNode<Type>*startNode)

{

      int diff,left,right;

 

      if(startNode==NULL)

             return true;

      left=treeDepth(startNode->left);

      right=treeDepth(startNode->right);

      diff=left-right;

      if(diff>1||diff<-1)

             return false;

      else

             returnbalanceTree(startNode->left)&&balanceTree(startNode->right);

 

}

 

int main()

{

 

      BStree<int> tree;

      int num;

      while(cin>>num)

      tree.createBitree(num);

      cout<<"输出递归先序遍历的序列"<<endl;

      tree.preOrder(tree.GetRoot());

      cout<<endl;

      cout<<"输出递归中序遍历的序列"<<endl;

      tree.inOrder(tree.GetRoot());

      cout<<endl;

      cout<<"输出递归后序遍历的序列"<<endl;

      tree.PostOrder(tree.GetRoot());

      cout<<endl;

      cout<<"输出非递归先序遍历的序列"<<endl;

      tree.noRecursivePre(tree.GetRoot());

      cout<<endl;

      cout<<"输出非递归中序遍历的序列"<<endl;

      tree.noRecursiveIn(tree.GetRoot());

      cout<<endl;

      cout<<"输出非递归后序遍历的序列"<<endl;

      tree.noRecursivePost1(tree.GetRoot());

      cout<<endl;

      cout<<"输出非递归后序遍历的序列2"<<endl;

      tree.noRecursivePost2(tree.GetRoot());

      cout<<endl;

      cout<<"输出二叉树节点之间的最大距离:"<<endl;

      tree.FindMaxLen(tree.GetRoot());

      cout<<maxlen<<endl;

      cout<<"输出二叉树两个节点之间的最低公共节点"<<endl;

      cout<<tree.findLCA(tree.GetRoot(),5,9)<<endl;

      cout<<"输出二叉树任意两个节点之间的距离"<<endl;

      tree.FindLen(tree.GetRoot(),11,14);

      cout<<distancebetweenNode<<endl;

      cout<<"输出二叉树的深度"<<endl;

   cout<<tree.treeDepth(tree.GetRoot())<<endl;

      cout<<"输出二叉树的宽度"<<endl;

      cout<<tree.treeWidth(tree.GetRoot())<<endl;

      cout<<"判断是否为平衡二叉树"<<endl;

      cout<<tree.balanceTree(tree.GetRoot())<<endl;

 

    system("pause");

      return 0;

}

mffjin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的基本操作
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树的宽度
Dablelv 的博客专栏。
04-06 6万+
二叉树的宽度定义为具有最多结点数的层中包含的结点数。比如上图中，第 1 层有 1 个结点， 第 2 层有 2 个结点， 第 3 层有 4 个结点， 第 4 层有 1 个结点。可知，第 3 层的结点数最多，所以这棵二叉树的宽度是 4。
python二叉树
惊鸿的博客
03-12 5791
二叉树特征定义 特征 树是一种 非线性的数据结构，，直观的看，他是数据元素（在树中称为结点）按分支关系组织起来的结构，很像自然界中的树那样，树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可以用树形象来表示。还有比如在编译程序的时候，它可以用来表示源程序的语法结构，又或者在数据库中，树型结构也是信息的重要组织形式之一。 总之：一切具有层次关系的问题都可以用树来描述。 定义 树（Tree）是n（≥0）个节点的有限集。在任意一棵树中： 1、有且仅有一个称为根（Root）的结点 2、当n&g
c++的二叉树
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
图解线索二叉树
weixin_44067399的博客
07-07 2万+
今天我们来聊聊线索二叉树 线索二叉树的诞生背景 对于n个结点的二叉树，则在二叉链存储结构中就会有n+1个空链域 当我在查找某个结点的时候，想要知道这个节点的前驱结点或者后继结点，我该怎么做？ 1.我是不是可以先序遍历或者后序遍历得到他们的前驱或者后继 2.我是不是可以开辟内存空间，对于每个结点增加一个指向它的前驱，增加一个指向它的后继 利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针，这些指针称为线索，加上线索的二叉树称为线索二叉树。 关于线索二叉树你所需要知道的 重要 如果一个结点的
线索二叉树
weixin_45863060的博客
05-18 1万+
线索二叉树 线索二叉树的概念： 1.线索： 线索是一种对二叉树的操作，意思是对二叉树进行线索化，其目的是使线索化后的二叉树具有方便被遍历的特点，被线索化后的二叉树实际上是一个双向链表。 2.基于中序遍历的线索二叉树： 中序遍历，即先遍历节点的左孩子，再遍历节点本身，最后遍历节点的右孩子。 3.前驱与后继： 基于这样的顺序得到的对所有节点的遍历顺序中，在某一节点前一个被遍历的节点称之为该节点的前驱，而在该节点后一个被遍历的节点称之为该节点的后继。 4.线索化节点的标记： 线索二叉树的节点定义有所改变，需要两个
二叉树
Black_SpiderC的博客
06-02 2259
二叉树的特点 1.每个结点最多有两棵子树，所以二叉树中不纯在度大于2的结点。注意不是只有两棵子树，而是最多有。没有子树或者只有一棵子树也是可以的。 2.左子树和右子树是有区别的，必须分开来 3.即使树中只有一棵子树，也要区别是左子树还是右子树 二叉树的五种基本形态 1.空二叉树 2.只有一个根结点 3. 根结点只有左子树 4.根结点只有右子树 5.根结点即有左子树又有右子树 特殊二叉树 1. 斜树 顾名思义，斜树一定要是斜的： 所有结点都只有左子树的二叉树叫做左斜树； 所有结点都是只有右子树的二叉树叫做右斜
线索二叉树简述
刘伟佳的博客
03-12 2751
线索二叉树 首先我们回忆一下二叉树的前中后序遍历方式： 先序遍历序列：1 2 4 5 3 6 中序遍历序列：4 2 5 1 6 3 后序遍历序列：4 5 2 6 3 1 我们通过这样的遍历，由一个树形结构得到了一个线性的结构（遍历序列）。在这个线性序列中，除了第一个结点和最后一个结点，每个结点都拥有一个前驱和后继。 那么在二叉树中，我们能不能不只体现结点的父子关系，也引入结点的前驱后继关系呢？ 由此，我们引入了线索二叉树。 我们之前说过二叉链表，我们知道在一个二叉链表中，n个结点会有n+1个空指针。 接
二叉树详解
weixin_59371851的博客
07-09 5万+
目录前言一、树的概念和结构1、树的概念2、树的表示 3、树在实际中的应用（表示文件系统的目录树结构）二、二叉树概念及结构1.概念 2、特殊的二叉树3、二叉树的性质4、二叉树的存储4.1顺序存储4.2链状存储 三、二叉树的顺序结构和实现1、二叉树的顺序结构2、堆的概念及结构3、堆的实现3.1堆的代码框架3.2堆的插入3.3堆的删除3.4堆的建立 3.5建堆的时间复杂度 4、堆的应用4.1堆排序 4.2TOP-K问题四、二叉树链式结构的实现 1、建二叉树2、二叉树的遍历2.1前序、中序以及后序遍历2.2层序遍历
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
易语言二叉树遍历
07-21
在易语言中，处理数据结构如二叉树是一项常见的任务，特别是在处理递归和树形结构的数据时。二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： ...
二叉树二叉树二叉树二叉树二叉树
05-01
二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
2进制3位数过去现在将来输赢公式代码.txt
09-07
2进制3位数过去现在将来输赢公式代码
福州大学在广东2021-2024各专业最低录取分数及位次表.pdf
最新发布
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
WordPress 集网址、资源、资讯于一体的导航类主题开心版
09-07
WordPress 集网址、资源、资讯于一体的导航类主题开心版； 运行环境 PHP7.4 + MYSQL5.6
【Java学习】activemq消息中间件学习demo.zip
09-07
【Java学习】activemq消息中间件学习demo.zip 【Java学习】activemq消息中间件学习demo.zip 【Java学习】activemq消息中间件学习demo.zip
二叉树遍历与线索二叉树详解
"树和二叉树是数据结构中的重要概念，主要讨论在计算机科学中用于组织和存储数据的非线性数据结构。二叉树由根节点、左子树和右子树三个基本单元构成，其特性使得遍历成为关键操作。本节关注于二叉树的遍历方式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值