树——二叉树的克隆比较和相加

Posted dishengandziyu

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了树——二叉树的克隆比较和相加相关的知识,希望对你有一定的参考价值。

1,二叉树的克隆操作:

       1,SharedPointer< BTree<T> > clone() const:

              1,克隆当前树的一份拷贝;

              2,返回值为堆空间中的一棵新二叉树(与当前树相等):

                     1,保存数据元素,树的属性一模一样;

                    

2,二叉树的克隆的实现:

技术图片

       1,定义功能:clone(node)

              1,拷贝 node 为根结点的二叉树(数据元素在对应位置相等);

       2,功能函数代码实现:

 1    /* 实现递归克隆函数,这个函数实现了结点之间的链接 */
 2     BTreeNode<T>* clone(BTreeNode<T>* node) const
 3     {
 4         BTreeNode<T>* ret = NULL;
 5 
 6         if( node != NULL )  // 被克隆的二叉树非空
 7         {
 8             ret = BTreeNode<T>::NewNode();
 9 
10             if( ret != NULL )
11             {
12                 ret->value = node->value;  // 先将数据拷贝出来
13                 ret->left = clone(node->left);
14                 ret->right = clone(node->right);
15 
16                 if( ret->left != NULL ) // 左子树不为空,指定父子关系
17                 {
18                     ret->left->parent = ret;  // 左子树父亲是当前结点
19                 }
20 
21                 if( ret->right != NULL )  // 右子树不为空,指定父子关系
22                 {
23                     ret->right->parent = ret;  // 右子树父亲是当前结点
24                 }
25             }
26             else
27             {
28                 THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new node ...");
29             }
30         }
31 
32         return ret;
33     }

  3,克隆成员函数代码实现:

 1     /* 克隆一个二叉树 */
 2     SharedPointer< BTree<T> > clone() const
 3     {
 4         BTree<T>* ret = new BTree<T>();
 5 
 6         if( ret != NULL )
 7         {
 8             ret->m_root = clone(root());  // 克隆当前树的根结点
 9         }
10         else
11         {
12             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new tree ...");
13         }
14 
15         return ret;
16     }

 

3,二叉树比较操作的定义:

 技术图片

       1,判断两棵二叉树中的数据元素是否对应相等(递归的实现):

              1,bool operator == (const BTree<T>& btree)

              2,bool operator != (const BTree<T>& btree)

                     1,二叉树的比较是递归进行的,因此要定义具体的相等功能;

                    

4,二叉树的比较的实现:

     技术图片

       1,定义功能:equal(lh, rh)

              1,判断 lh 为根结点的二叉树与 rh 为根结点的二叉树是否相等;

       2,功能函数代码实现:

 1    /*实现两颗二叉树是否相等的递归功能函数,参数为两个根结点*/
 2     bool equal(BTreeNode<T>* lh, BTreeNode<T>* rh) const
 3     {
 4         if( lh == rh )  // 自己和自己比较,相等
 5         {
 6             return true;
 7         }
 8         else if( (lh != NULL) && (rh != NULL) )
 9         {   /* 判断值、递归判断左子树和右子树是否相等 */
10             return (lh->value == rh->value) && equal(lh->left, rh->left) && equal(lh->right, rh->right);
11         }
12         else
13         {
14             return false;  // 一个二叉树为空树,另一颗二叉树不为空
15         }
16     }

  3,相等和不等操作符重载的代码实现:

 1     /* 两个二叉树相等 */
 2     bool operator == (const BTree<T>& btree)
 3     {
 4         return equal(root(), btree.root());
 5     }
 6 
 7     /* 两颗二叉树不相等 */
 8     bool operator != (const BTree<T>& btree)
 9     {
10         return !(*this == btree);
11     }

 

5,二叉树的相加操作:

 技术图片

       1,SharedPointer< BTree<T> > add(const BTree<T>& btree) const

              1,将当前二叉树与参数 btree 中的数据元素在对应位置处相加;

              2,返回值(相加的结果)为堆空间中的一棵新二叉树;

             

6,二叉树加法的实现:

      技术图片

       1,定义功能:add(lh, rh)

              1,将 lh 为根结点的二叉树与 rh 为根结点的二叉树相加;

              2,前两中情况刚好对应了小树和大树相加中,小树部分为空、大树部分不为空的情形;

       2,功能函数代码实现:

 1    /* 两颗二叉树相加的功能函数 */
 2     BTreeNode<T>* add(BTreeNode<T>* lh, BTreeNode<T>* rh) const
 3     {
 4        BTreeNode<T>* ret = NULL;
 5 
 6        if( (lh == NULL) && (rh != NULL) )
 7        {
 8            ret = clone(rh);  // 相加直接为非空的树
 9        }
10        else if( (lh != NULL) && (rh == NULL) )
11        {
12            ret = clone(lh);  // 相加直接为非空的树
13        }
14        else if( (lh != NULL) && (rh != NULL) )
15        {
16            ret = BTreeNode<T>::NewNode();
17 
18            if( ret != NULL )
19            {
20                ret->value = lh->value + rh->value;  // 结点的值直接相加
21                ret->left = add(lh->left, rh->left);  // 递归实现左子树相加
22                ret->right = add(lh->right, rh->right);  // 递归实现右子树相加
23 
24                if( ret->left != NULL )  // 左子树父结点设置为当前的结点
25                {
26                    ret->left->parent = ret;
27                }
28 
29                if( ret->right != NULL )  // 右子树父结点设置为当前的结点
30                {
31                    ret->right->parent = ret;
32                }
33            }
34            else
35            {
36                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new node ...");
37            }
38        }
39 
40        return ret;
41     }

  3,相加成员函数代码实现:

 1     /* 执行加法操作 */
 2     SharedPointer< BTree<T> > add(const BTree<T>& btree) const
 3     {
 4         BTree<T>* ret = new BTree<T>();  // 创建一棵要返回的树;
 5         if( ret != NULL )
 6         {
 7             ret->m_root = add(root(),btree.root());  // 以结点链接这个树;
 8         }
 9         else
10         {
11             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new tree ...");
12         }
13         return ret;
14     }

 

7,小结:   

       1,比较操作判断两棵二叉树中的数据元素是否对应相等;

       2,克隆操作将当前二叉树在堆空间中进行复制;

       3,相加操作将两棵二叉树中的数据元素在对应位置处相加;

       4,相加操作的结果保存在堆空间的一棵二叉树中;

以上是关于树——二叉树的克隆比较和相加的主要内容,如果未能解决你的问题,请参考以下文章

二叉树的操作

二叉树的操作

二叉树路径

数据结构题目二叉树遍历,哪位大神帮忙解答下,谢谢!

二叉树:合并两个二叉树

二叉树的优点和缺点