二叉树的基本操作

于 2016-11-18 14:23:00 发布
阅读量292 收藏
点赞数
分类专栏： 加油 文章标签： 二叉树 递归算法 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzhustu/article/details/53215938
版权

最近被数模搞疯了，没有什么事情是容易的。二叉树有很多性质，也包括一些递归算法，看起来很有意思，递归不要懂得太多。我还是想学习，做一个美男子，呵呵哒。各种不同的遍历，线索树我还没学太懂。
还有树的创建方法（前中序，中后序，输入法（#结束））

#include <iostream>
#include<queue>
#include<stack>
using namespace std;
template<class T>
class BinaryTreeNode
{
public:
    T element;
    BinaryTreeNode<T> *leftchild;
    BinaryTreeNode<T> *rightchild;
public:
    BinaryTreeNode();
    BinaryTreeNode(const T& ele,BinaryTreeNode<T>*l=NULL,BinaryTreeNode<T>*r=NULL);
    BinaryTreeNode<T> *getLeftchild();
    BinaryTreeNode<T> *getRightchild();
    void    setLeftchild(BinaryTreeNode<T>*l);
    void    setRightchild(BinaryTreeNode<T>*r);
    T       getValue();
    void    setValue(T& val);
    bool    isLeaf();

};
template<class T>
BinaryTreeNode<T>::BinaryTreeNode()
{
    element=NULL;
    leftchild=NULL;
    rightchild=NULL;

}
template<class T>
BinaryTreeNode<T>::BinaryTreeNode(const T& ele,BinaryTreeNode<T>*l,BinaryTreeNode<T>*r)
{
    element=ele;
    leftchild=l;
    rightchild=r;
}
template<class T>
BinaryTreeNode<T>* BinaryTreeNode<T>::getLeftchild()
{
    return leftchild;
}
template<class T>
BinaryTreeNode<T>* BinaryTreeNode<T>::getRightchild()
{
    return rightchild;
}
template<class T>
void BinaryTreeNode<T>::setLeftchild(BinaryTreeNode<T>*l)
{
    leftchild=l;
}
template<class T>
void BinaryTreeNode<T>::setRightchild(BinaryTreeNode<T>*r)
{
    rightchild=r;
}
template<class T>
T BinaryTreeNode<T>::getValue()
{
    return element;
}

template<class T>
void BinaryTreeNode<T>::setValue(T & ele)
{
    element=ele;
}
template<class T>
bool BinaryTreeNode<T>::isLeaf()
{
    if(leftchild==NULL&&rightchild==NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}
template<class T>
class BinaryTree{

public:
    BinaryTreeNode<T> *root;
    int count_0;
    int count_1;
    int count_2;
    int height;
    int width;
    T   max;
public:
    BinaryTree(){
     count_0=0;
     count_1=0;
     count_2=0;
     height=0;
     width=0;
     max=NULL;
    };
    //~BinaryTree();
    bool isEmpty();
    BinaryTreeNode<T> *getParent(BinaryTreeNode<T> *current);
    bool creat(BinaryTreeNode<T> *&root);
    bool Creat();
    BinaryTreeNode<T> *getLeftSibling(BinaryTreeNode<T> *current);
    BinaryTreeNode<T> *getRightSibling(BinaryTreeNode<T> *current);
    void breathFistOrder(BinaryTreeNode<T> *root);
    void preOrder(BinaryTreeNode<T> *root);
    void inOrder(BinaryTreeNode<T> *root);
    void postOrder(BinaryTreeNode<T> *root);
    void preOrderWithoutRecusion(BinaryTreeNode<T> *root);
    void inOrderWithoutRecusion(BinaryTreeNode<T> *root);
    void postOrderWithoutRecusion(BinaryTreeNode<T> *root);
    void LevelOrder(BinaryTreeNode<T> *root);
    void deleteBinaryTree(BinaryTreeNode<T> *root);
    BinaryTreeNode<T>* createBianryTreeByinpost(T A[],int b1,int e1,T B[],int b2,int e2);
    BinaryTreeNode<T>* createBianryTreeByinpre(T A[],int b1,int e1,T B[],int b2,int e2);
    int mounted_Degree_1(BinaryTreeNode<T>* root);
    int mounted_Degree_2(BinaryTreeNode<T>* root);
    int mounted_Degree_0(BinaryTreeNode<T>* root);
    int mounted_TreeHeight(BinaryTreeNode<T>* root);
    int mounted_Width(BinaryTreeNode<T>* root,int level);
    T   mounted_Max(BinaryTreeNode<T>* root);
    BinaryTreeNode<T>* swap_TreeNode(BinaryTreeNode<T>* root);
    int delete_LeafNode(BinaryTreeNode<T>* root);
    bool isComplete_Binarytree(BinaryTreeNode<T>* root);
};
template<class T>
bool BinaryTree<T>::isComplete_Binarytree(BinaryTreeNode<T>* root)
{
    /* */
    using std::queue;
    queue<BinaryTreeNode<T> *>nodeQueue;
    BinaryTreeNode<T>* ptr;
    nodeQueue.push(root); /* store the TreeNOde, NULL NOde included,using queque to memorize the order */
    while((ptr=nodeQueue.front())!=NULL)
    {
        nodeQueue.pop();
        nodeQueue.push(ptr->leftchild);
        nodeQueue.push(ptr->rightchild);
    }
    while(!nodeQueue.empty())/*finally the queue is filled with NULL NOde,if the tree is complete Tree*/
    {
        ptr=nodeQueue.front();
        nodeQueue.pop();
        if(ptr!=NULL)
        {
            return false;
        }
    }
    return true;
}
template<class T>
int BinaryTree<T>::delete_LeafNode(BinaryTreeNode<T>* rt)
{
    if(rt==NULL)
    {
        return NULL;

    }
    if(rt->rightchild==NULL&&rt->leftchild==NULL)
    {
        rt->element=NULL;/*delete,if delete it,clear the tree?*/
    }
    delete_LeafNode(rt->rightchild);
    delete_LeafNode(rt->leftchild);

}
template<class T>
BinaryTreeNode<T>* BinaryTree<T>::swap_TreeNode(BinaryTreeNode<T>* rt)
{
   if(rt==NULL||(rt->leftchild==NULL&rt->rightchild==NULL))
   {
       return rt;
   }
   BinaryTreeNode<T>* temp;
   temp=rt->leftchild;
   rt->leftchild=rt->rightchild;
   rt->rightchild=temp;
   if(rt->leftchild)
   {
       rt->leftchild=swap_TreeNode(rt->leftchild);
   }
   if(rt->rightchild)
   {
       rt->rightchild=swap_TreeNode(rt->rightchild);
   }
   return rt;
}
template<class T>
T  BinaryTree<T>::mounted_Max(BinaryTreeNode<T>* rt)
{
      if(rt!=NULL)
    {
        if(max<rt->element)
        {
            max=rt->element;
        }
        mounted_Max(rt->leftchild);
        mounted_Max(rt->rightchild);
        return max;
    }
    else
    {
        return NULL;
    }
}
int count[100];
template<class T>
int BinaryTree<T>::mounted_Width(BinaryTreeNode<T>* rt,int level)
{
      if(rt==NULL)
      {
          return NULL;
      }
      count[level]++;
      if(width<count[level])
      {
          width=count[level];
      }
      mounted_Width(rt->leftchild,level+1);
      mounted_Width(rt->rightchild,level+1);/*遍历的过程也是++的过程*/
      return width;
}
template<class T>
 int BinaryTree<T>::mounted_TreeHeight(BinaryTreeNode<T>* rt)
 {
   if(rt!=NULL)
   {
      int u=mounted_TreeHeight(rt->leftchild);
      int v=mounted_TreeHeight(rt->rightchild);
      if(u>v)
      {
          height=u+1;
          return u+1;
      }
      height=v+1;
      return  height;

   }
   else
   {
       return 0;
   }

 }
template<class T>
 int BinaryTree<T>::mounted_Degree_1(BinaryTreeNode<T>* rt)
 {
   if(rt!=NULL)
   {
       if(rt->leftchild==NULL&&rt->rightchild!=NULL)
       {
           count_1+=1;
           mounted_Degree_1(rt->rightchild);
       }
      else if(rt->rightchild==NULL&&rt->leftchild!=NULL)
       {
           count_1+=1;
           mounted_Degree_1(rt->leftchild);
       }
       else
       {
           mounted_Degree_1(rt->leftchild);
           mounted_Degree_1(rt->rightchild);
       }

   }
   return count_1;
 }
 template<class T>
 int BinaryTree<T>::mounted_Degree_2(BinaryTreeNode<T>* rt)
 {
   if(rt!=NULL)
   {
       if(rt->leftchild!=NULL&&rt->rightchild!=NULL)
       {
           count_2+=1;


       }
           mounted_Degree_2(rt->leftchild);
           mounted_Degree_2(rt->rightchild);

   }
   return count_2;
 }
  template<class T>
 int BinaryTree<T>::mounted_Degree_0(BinaryTreeNode<T>* rt)
 {
   if(rt!=NULL)
   {
       if(!rt->leftchild&&!rt->rightchild)
       {
           count_0+=1;
       }
           mounted_Degree_0(rt->leftchild);
           mounted_Degree_0(rt->rightchild);

   }
   return count_0;
 }
template<class T>
bool createBinaryTree(BinaryTreeNode<T> *b)
{
    cout<<"dd"<<endl;
    int a;
    cout<<"ÊäÈë½Ó¿Ú"<<endl;
    cin>>a;
    if(a==0)
    {

        return true;
    }
    else
    {
        b=new BinaryTreeNode<T>;
        b->element=a;
        createBinaryTree(b->leftchild);
        createBinaryTree(b->leftchild);
    }
}
template<class T>
void visit(BinaryTreeNode<T> *root)
{
    cout<<root->element<<endl;
}
template<class T>
void BinaryTree<T>::LevelOrder(BinaryTreeNode<T> *root)
{
    using std::queue;
    queue<BinaryTreeNode<T> *>nodeQueue;
    BinaryTreeNode<T> *pointer=root;
    if(pointer)
    {

        nodeQueue.push(pointer);
    }
    while(!nodeQueue.empty())
    {
        pointer=nodeQueue.front();
        visit(pointer);
        nodeQueue.pop();
        if(pointer->leftchild)
            nodeQueue.push(pointer->leftchild);
        if(pointer->rightchild)
            nodeQueue.push(pointer->rightchild);
    }
}
template<class T>
void BinaryTree<T>::preOrder(BinaryTreeNode<T> *root)
{
    if(root!=NULL)
    {
        visit(root);
        preOrder(root->leftchild);
        preOrder(root->rightchild);
    }
}
template<class T>
void BinaryTree<T>::inOrder(BinaryTreeNode<T> *root)
{
    if(root!=NULL)
    {
        inOrder(root->leftchild);
        visit(root);

        inOrder(root->rightchild);
    }
}
template<class T>
void BinaryTree<T>::postOrder(BinaryTreeNode<T> *root)
{
    if(root!=NULL)
    {
        postOrder(root->leftchild);
        postOrder(root->rightchild);
        visit(root);


    }
}
template<class T>
void BinaryTree<T>::preOrderWithoutRecusion(BinaryTreeNode<T> *root)
{
    using std::stack;
    stack<BinaryTreeNode<T> *>nodestack;
    BinaryTreeNode<T>* pointer=root;
    while(!nodestack.empty()||pointer)
    {
        if(pointer)
        {
            nodestack.push(pointer);
            visit(pointer);
            pointer=pointer->leftchild;
        }
        else
        {
            pointer=nodestack.top();

            pointer=pointer->rightchild;
             nodestack.pop();
        }
    }
}
template<class T>
void BinaryTree<T>::inOrderWithoutRecusion(BinaryTreeNode<T> *root)
{
    using std::stack;
    stack<BinaryTreeNode<T> *>nodestack;
    BinaryTreeNode<T>* pointer=root;
    while(!nodestack.empty()||pointer)
    {
        if(pointer)
        {
            nodestack.push(pointer);
            pointer=pointer->leftchild;
        }
        else
        {
            pointer=nodestack.top();
            visit(pointer);
            pointer=pointer->rightchild;
            nodestack.pop();
        }
    }
}
template<class T>
void BinaryTree<T>::postOrderWithoutRecusion(BinaryTreeNode<T> *root)
{
    using std::stack;
    stack<BinaryTreeNode<T> *>nodestack;
    BinaryTreeNode<T>* pointer=root;
    BinaryTreeNode<T>* pre=root;
    while(pointer)
    {
        for(;pointer->leftchild!=NULL;pointer=pointer->leftchild)
            nodestack.push(pointer);
        while(pointer!=NULL&&(pointer->rightchild==NULL||pointer->rightchild==pre))
        {
            visit(pointer);
            pre=pointer;
            if(nodestack.empty())
                return;
            pointer =nodestack.top();
            nodestack.pop();
        }
        nodestack.push(pointer);
        pointer=pointer->rightchild;
    }
}
template<class T>
bool BinaryTree<T>::Creat()
{
    if(creat(root));
        return true;
    return false;
}
template<class T>
bool BinaryTree<T>::creat(BinaryTreeNode<T> *&root)
{
    T tempaval;
    cin>>tempaval;
    if(tempaval!='#')
    {
        root=new BinaryTreeNode<T>;
        if(!root)
        {
            root=NULL;
            return false;
        }
        root->element=tempaval;
        if(!creat(root->leftchild))
            root->leftchild=NULL;
        if(!creat(root->rightchild))
            root->rightchild=NULL;
    }
    else
        return false;
    return true;
}
template <class T>
BinaryTreeNode<T>* BinaryTree<T>::createBianryTreeByinpost(T A[],int b1,int e1,T B[],int b2,int e2)/*zhong-hou*/
{
    T rtdata=B[e2];
    int k=0;
    for(k=b1;k<=e1;k++)
    {
        if(A[k]==rtdata)
        {
            break;
        }
    }
    if(k>e1)
    {
        return NULL;
    }
  BinaryTreeNode<T>*  root_1=new BinaryTreeNode<T>(rtdata,NULL,NULL);
   int leftlen=k-b1;
   int rightlen=e1-k;

   if(leftlen>0)
   {
       root_1->leftchild=createBianryTreeByinpost(A,b1,b1+leftlen-1,B,b2,b2+leftlen-1);
   }

   if(rightlen>0)
   {
       root_1->rightchild=createBianryTreeByinpost(A,k+1,e1,B,b2+leftlen,e2-1);
   }
  return root_1;

}
template <class T>
BinaryTreeNode<T>* BinaryTree<T>::createBianryTreeByinpre(T A[],int b1,int e1,T B[],int b2,int e2)/*zhong-qian*/
{
    T rtdata=B[b2];
    int k=0;
    for(k=b1;k<=e1;k++)
    {
        if(A[k]==rtdata)
        {
            break;
        }
    }
    if(k>e1)
    {
        return NULL;
    }
  BinaryTreeNode<T>*  root_1=new BinaryTreeNode<T>(rtdata,NULL,NULL);
   int leftlen=k-b1;
   int rightlen=e1-k;
   if(leftlen>0)
   {
       root_1->leftchild=createBianryTreeByinpre(A,b1,b1+leftlen-1,B,b2+1,b2+leftlen);
   }
   if(rightlen>0)
   {
       root_1->rightchild=createBianryTreeByinpre(A,k+1,e1,B,b2+leftlen+1,e2);
   }
   return root_1;
}
int main()
{
    BinaryTree<char> s;

    char A[8]={'B','F','D','G','A','C','E','H'};
    char B[8]={'F','G','D','B','H','E','C','A'};
    char C[8]={'A','B','D','F','G','C','E','H'};
   //s.root= s.createBianryTreeByinpost(A,0,7,B,0,7);
   s.root= s.createBianryTreeByinpre(A,0,7,C,0,7);
    cout<<"in oder:"<<endl;
    s.inOrder(s.root);
    cout<<"----------------"<<endl;
    s.inOrderWithoutRecusion(s.root);
    cout<<"post oder:"<<endl;
  s.postOrder(s.root);
  cout<<"----------------"<<endl;
    s.postOrderWithoutRecusion(s.root);
    cout<<"pre oder:"<<endl;
   s.preOrder(s.root);
   cout<<"----------------"<<endl;
    s.preOrderWithoutRecusion(s.root);
    cout<<"Level oder:"<<endl;
    s.LevelOrder(s.root);
      cout<<"Test width:"<<endl;
cout<<s.mounted_Width(s.root,0)<<endl;
      cout<<"Test height:"<<endl;
cout<<s.mounted_TreeHeight(s.root)<<endl;
 cout<<"Test Degree 0:"<<endl;
cout<<s.mounted_Degree_0(s.root)<<endl;
cout<<"Test Degree 1:"<<endl;
cout<<s.mounted_Degree_1(s.root)<<endl;
cout<<"Test Degree 2:"<<endl;
cout<<s.mounted_Degree_2(s.root)<<endl;
cout<<"Test MaxValue:"<<endl;
cout<<s.mounted_Max(s.root)<<endl;
cout<<"Test Swap:"<<endl;
s.postOrder(s.root);
cout<<"----------------"<<endl;
s.root=s.swap_TreeNode(s.root);
s.postOrder(s.root);
cout<<"----------------"<<endl;
cout<<"Test deleteLeaf"<<endl;
s.delete_LeafNode(s.root);
s.postOrder(s.root);
cout<<"Test Is copmpleteTree"<<endl;
cout<<s.isComplete_Binarytree(s.root);

    return 0;
}
Transcend2022
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PAT1066 Root of AVL平衡二叉树的插入
weixin_44405344的博客
03-16 145
#include &lt;stdio.h&gt; #include&lt;iostream&gt; #include &lt;string.h&gt; #include &lt;string&gt; #include &lt;algorithm&gt; #include &lt;map&gt; #include &lt;vector&gt; #include &lt;set&gt;
排序二叉树的基本操作
热门推荐
Jesse的专栏
05-16 1万+
#include "iostream" using namespace std; typedef struct da {  int num;  struct da *left,*right; }dat,*data; int search(data temp,int n) {  if(temp == NULL)   return 1;  if(temp ->num == n)
二叉树基本操作
04-30
1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和...
二叉树-基于C语言实现的二叉树基本操作.zip
最新发布
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
二叉树基本操作_二叉树基本操作_
10-02
二叉树的基本操作主要包括创建、查找、插入和删除节点，这些操作对于理解和掌握二叉树至关重要。接下来，我们将详细讨论这些操作。 1. **创建二叉树** 创建一个二叉树首先需要定义二叉树节点的数据结构。在链表...
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
这篇文档“二叉树基本操作的程序实现”涵盖了二叉树的一些核心概念和基本操作，旨在帮助初学者理解并实现这些概念。 二叉树由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的主要类型有...
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
二叉树 基本操作
04-21
先序、中序、后序遍历二叉树(递归算法)!;3.中序遍历二叉树(非递归算法)!求二叉树的高度!求二叉树的叶子个数!;对于树中每一个元素值为x的结点，删去以它为根的子树，并释放相应的空间!借助队列实现二叉树的层次遍历!
二叉树基本操作.rar
04-24
平衡二叉树的插入和删除操作都需要进行旋转操作来维持平衡状态，从而保证查找操作的时间复杂度为O(log n)。 二叉搜索树：在二叉搜索树中，任意节点的左子树只包含小于该节点的值，右子树只包含大于该节点的值。这...
C++实现二叉树基本操作详解
08-28
C++ 实现二叉树基本操作详解 二叉树是一种重要的非线性数据结构，广泛应用于计算机科学和信息技术领域。为了帮助读者更好地理解和掌握二叉树的基本操作，本文将详细介绍 C++ 语言实现二叉树基本操作的方法和技术。 ...
C++二叉树基本操作
07-03
这个压缩包文件“C++二叉树基本操作”显然是一个关于使用C++实现二叉树操作的示例代码集，对于学习C++和数据结构的人来说极具价值。 二叉树是由节点（或称为元素）构成的数据结构，每个节点最多有两个子节点，通常...
C语言二叉树基本操作
11-21
以上就是C语言中二叉树基本操作的核心内容。通过创建节点、插入节点和进行前序遍历，我们可以对二叉树进行基本的操作和理解。这些概念是进一步学习二叉树的其他操作（如中序遍历、后序遍历、层次遍历等）的基础，也...
二叉树基本操作的实现
10-25
二叉树是一种非常重要的数据结构，它的基本操作包括创建、销毁、遍历、查找等。下面是二叉树基本操作的实现方法： 1. 创建二叉树：通过前序遍历的数组构建二叉树，其中 '#' 表示空节点。具体实现方法可以参考引用中的 BinaryTreeCreate 函数。 2. 销毁二叉树：遍历二叉树，依次释放每个节点的内存空间。具体实现方法可以参考引用中的 BinaryTreeDestory 函数。 3. 遍历二叉树：二叉树的遍历包括前序遍历、中序遍历、后序遍历和层序遍历。具体实现方法可以参考引用中的 BinaryTreePrevOrder、BinaryTreeInOrder、BinaryTreePostOrder 和 BinaryTreeLevelOrder 函数。 4. 查找二叉树节点：在二叉树中查找值为 x 的节点，具体实现方法可以参考引用中的 BinaryTreeFind 函数。 5. 计算二叉树节点个数：计算二叉树中节点的个数，具体实现方法可以参考引用[2]中的 BinaryTreeSize 函数。 6. 计算二叉树叶子节点个数：计算二叉树中叶子节点的个数，具体实现方法可以参考引用中的 BinaryTreeLeafSize 函数。 7. 计算二叉树第 k 层节点个数：计算二叉树中第 k 层节点的个数，具体实现方法可以参考引用中的 BinaryTreeLevelKSize 函数。 8. 判断二叉树是否是完全二叉树：判断二叉树是否是完全二叉树，具体实现方法可以参考引用中的 BinaryTreeComplete 函数。 9. 计算二叉树的深度：计算二叉树的深度，具体实现方法可以参考引用中的 BinaryTreeDeep 函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值