EssentialC++_chapter06 binary tree 的学习笔记记录及问题

Dreams0000

已于 2023-04-24 20:54:55 修改

阅读量285

点赞数 1

分类专栏： C++学习数据结构和算法分析文章标签： c++ 数据结构算法链表

于 2021-02-28 10:11:48 首次发布

本文链接：https://blog.youkuaiyun.com/Dallas01/article/details/114210231

版权

数据结构和算法分析同时被 2 个专栏收录

5 篇文章

订阅专栏

C++学习

2 篇文章

订阅专栏

Essential C++ chapter06 binary tree 的学习笔记记录及问题

Author：Dargon
Note date：2021/02/28
Source： 《Essential C++》 and 《C ++ primer plus》
Note: 关于二叉树的构建插入移除和打印利用C++ template
Version：更改错误关于输出 << 运算符的问题 2021/03/03

文章目录

Essential C++ chapter06 binary tree 的学习笔记记录及问题

1 BTnode class template 的构建

主要是对于tree 的节点信息的存储包括value值、左右子节点的指针在将此 Class 进行初始化，其余的就是数据结构里正常的树节点的insert remove and clear 等操作。

/***********************************************************
  * @name    Essential C++ 6th chapter
  * @brief   BTnode class 的声明区域
  * @date    2021/02/26 
*********************************************************/
template<typename elemType>
class BinaryTree; /* forward declaration */

template < typename valType >
class BTnode {
    friend class BinaryTree<valType>; /* 声明友元函数 需要在前面进行声明 */

    public:
        BTnode() {}
        BTnode( const valType &val );
        void insert_value( const valType& val );
        void remove_value( const valType &val, BTnode *& prev );
        static void lchild_leaf( BTnode *leaf, BTnode *subtree );

    private:
        valType _val; /* node 所存储的具体信息 值 */
        int _cnt; /* 记录重复次数 */
        BTnode *_lchild; /* 左右子节点 */
        BTnode *_rchild;

};

template<typename valType>
inline BTnode<valType>::
BTnode( const valType &val ) : _val(val) {
    _cnt =1;
    _lchild =_rchild =0;
}

template<typename valType>
void BTnode<valType>::
insert_value( const valType& val ) {
    if( val ==_val ) {
        _cnt++;
        return;
    }

    if( val <_val ) {
        if( ! _lchild ) {
            _lchild =new BTnode( val );
        }
        else {
            _lchild->insert_value( val );
        }
    }
    else {
        if( ! _rchild ) {
            _rchild =new BTnode( val );
        }
        else {
            _rchild->insert_value( val );
        }
    }
}

template<typename valType>
void BTnode<valType>::
remove_value( const valType &val, BTnode * & prev ) { /* 这个 “* & ” 是有点东西的 */
    if( val <_val ) {
        if( ! _lchild ) {
            return; /* 不在此 binary tree 中 */
        }
        else {
            _lchild->remove_value( val, _lchild ); /* 进行递归的 remove */
        }
    }
    else if( val >_val ) {
        if( ! _rchild ) {
            return;
        }
        else {
            _rchild->remove_value( val, _rchild );
        }
    }
    else {
        /* 找到需要删除的value */
        if( _rchild ) { /* 利用 右子树 进行 取代移除点的位置 */
            prev =_rchild;
            if( _lchild ) { /* 原来节点的左子树 */
                if( ! prev->_lchild ) {
                    prev->_lchild =_lchild;
                }
                else {
                    BTnode<valType>::lchild_leaf( _lchild, prev->_lchild );
                }
            }
            
        }
        else { /* remove节点 没有右子树 直接上左子树 */
            prev =_lchild; 
        }
        delete this; 
    }
        
}

template<typename valType>
inline void BTnode<valType>::
lchild_leaf( BTnode *leaf, BTnode *subtree ) {
    while( subtree->_lchild ) {
        /* 找左子树的 叶节点（最小值） */
        subtree =subtree->_lchild;
    }
    /* 将此 leaf 接在 左边最后面 */
    subtree->_lchild =leaf;
}

2 Binary Tree Class template 的构造

对于整体树的一个class template的构造其中遇到的一个问题在进行operator << 的重构时，出现不明问题 待解决代码部分已进行注释 其余的操作见代码。

/***********************************************************
  * @name    Essential C++ 6th chapter
  * @brief   BinaryTree class 的声明区域
  * @date    2021/02/26
*********************************************************/

template < typename elemType >
class BinaryTree {

    public:
        /*  这句没有按照书上的写友元函数  */
        //friend ostream& operator<<( ostream &, const BinaryTree<elemType>& );
        /* constructor */
        BinaryTree();
        BinaryTree( const BinaryTree& );
        /* destructor */
        ~BinaryTree();
        /* operator = */
        BinaryTree& operator=( const BinaryTree& );

        void insert( const elemType& );
        void remove( const elemType& elem );
        void remove_root();
        bool empty() { return _root ==0; }

        void clear() { if( _root ) { clear( _root ); _root =0;} } /* 对应下面自己家的clear */
        void preorder(); 
        void pre_recursion( BTnode<elemType> *node ); /* 所使用的输出 */
        void inorder();
        void in_recursion( BTnode<elemType> *node );
        void postorder();
        void post_recursion( BTnode<elemType> *node );

        void preorder( BTnode<elemType> *node, ostream &os =cout );        
        static ostream & display_val( elemType &nodevalue, ostream &os =cout );        
        BTnode<elemType> * get_root() { return _root; }

        ostream& print( ostream &os =cout );

    private:
        BTnode<elemType> *_root; /* 只声明一个 指向BTnode 型的指针 */
        void clear( BTnode<elemType> *node );
        /* copy operator */
        void copy( BTnode<elemType> *tar, BTnode<elemType> *src );
        
};

/* default constructor */
template<typename elemType>
inline BinaryTree<elemType>::BinaryTree() : _root(0) {}

/* copy constructor */
template<typename elemType>
inline BinaryTree<elemType>::BinaryTree( const BinaryTree &rhs ) {
    copy( _root, rhs._root );
}

template<typename elemType>
inline BinaryTree<elemType>::~BinaryTree() {
    clear();
}

template<typename elemType>
inline BinaryTree<elemType> &BinaryTree<elemType>:: /* 相当于 返回类型 */
operator=( const BinaryTree &rhs ) {
    if( this != &rhs ) {
        clear();
        copy( _root, rhs._root );
    }
    return *this;
}

/* insert */
template<typename elemType>
inline void BinaryTree<elemType>::
insert( const elemType &elem ) {
    if( ! _root ) {
        _root =new BTnode<elemType> (elem);
    }
    else {
        _root->insert_value( elem ); /* 还未初始化 */
    }
}

/* remove */
template<typename elemType>
inline void BinaryTree<elemType>::
remove( const elemType &elem ) {
    if( _root ) {
        if( _root->_val ==elem ) {
            remove_root(); /* 对于根节点的操作 特殊处理 */
        }
        else {
            _root->remove_value( elem, _root ); /* 正常情况的处理 */
        }
    }
}

template<typename elemType>
inline void BinaryTree<elemType>::
remove_root() {
    if( ! _root ) return;

    BTnode<elemType> *tmp =_root;
    /* 从右子树 下手 */
    if( _root->_rchild ) {
        _root =_root->_rchild; /* 右子树 取代根 的位置 */

        /* 下面只需要将根 的 左子树部分 搬移到 右子节点 左子树的底部 即可 */
        if( tmp->_lchild ) {
            BTnode<elemType> *lc =tmp->_lchild;     /* 原来根的 左子树 */
            BTnode<elemType> *newlc =_root->_lchild;/* 现在根的 左子树 */
            if( ! newlc ) { 
                /* 没有 直接接上 */
                _root->_lchild =lc; 
            }
            else {
                /* 有的话 找到左子树的 底部 接到下面就可以 */
                BTnode<elemType>::lchild_leaf( lc, newlc );
            }
        }
    }
    /* 直接 左子树 接上 */
    else {
        _root =_root->_lchild;
    }

    delete tmp; /* delete root node */
}

/* clear */
template<typename elemType>
inline void BinaryTree<elemType>::
clear( BTnode<elemType> *pt ) {
    if( pt ) {
        clear( pt->_lchild );
        clear( pt->_rchild );
        delete pt;
    }
}

/* preorder */
template<typename elemType>
inline void BinaryTree<elemType>::
preorder() {
    pre_recursion( _root );
}

template<typename elemType>
inline void BinaryTree<elemType>::
pre_recursion( BTnode<elemType> *node ) {
    if( node ) {
        std::cout << node->_val << " ";

        if( node->_lchild ) {
            pre_recursion( node->_lchild );
        }
        if( node->_rchild ) {
            pre_recursion( node->_rchild );
        }
    }
}

/* inorder */
template<typename elemType>
inline void BinaryTree<elemType>::
inorder() {
    in_recursion( _root );
}

template<typename elemType>
inline void BinaryTree<elemType>::
in_recursion( BTnode<elemType> *node ) {
    if( node ) {
        std::cout << node->_val << " ";

        if( node->_lchild ) {
            in_recursion( node->_lchild );
        }
        if( node->_rchild ) {
            in_recursion( node->_rchild );
        }
    }
}

/* postorder */
template<typename elemType>
inline void BinaryTree<elemType>::
postorder() {
    post_recursion( _root );
}

template<typename elemType>
inline void BinaryTree<elemType>::
post_recursion( BTnode<elemType> *node ) {
    if( node ) {
        std::cout << node->_val << " ";

        if( node->_lchild ) {
            post_recursion( node->_lchild );
        }
        if( node->_rchild ) {
            post_recursion( node->_rchild );
        }
    }
}

/* 未使用的遍历方法 */
template<typename elemType>
inline void BinaryTree<elemType>::
preorder( BTnode<elemType> *node, ostream &os ) {
    if( node ) {
        display_val( node->_val, os );
        preorder( node->_lchild, os );
        preorder( node->_rchild, os );
    }
}

template<typename elemType>
ostream & BinaryTree<elemType>::
display_val( elemType &nodevalue, ostream &os ) {
    os << nodevalue << ' ';
    return os;
}

template<typename elemType>
ostream & BinaryTree<elemType>::
print( ostream &os ) {
    preorder( _root, os );
    return os;
}

/* 关乎 输出运算符问题 此处更改错误 */
/* 把参数的 const 类型声明去掉 原因 是在调用时候 你所定义的函数就是 non-const类型 所以输出也要一样 */
template<typename elemType>
inline ostream&
operator<<( ostream &os, BinaryTree<elemType> &bt ) {
    os << "\nTree: " << endl;
    //return bt.print(os);
    return os;
}

3 关于class template 的测试

此处打印树使用前序遍历preorder 进行显示 “<<" 操作符未使用

int exercise_06_01() {
    BinaryTree<string> bt;

    bt.insert( "Piglet" );
    bt.insert( "Eeyore" );
    bt.insert( "Roo" );
    bt.insert( "Tigger" );
    bt.insert( "Chris" );
    bt.insert( "Pooh" );
    bt.insert( "Kanga" );

    cout << "Preorder tracersal: \n";
    bt.preorder();

    bt.remove( "Piglet" );
    cout << "\n\nPreorder traversal after Piglet remove: \n";
    bt.preorder();

    bt.remove( "Eeyore" );
    bt.insert( "Piglet" );
    cout << "\n\nPreorder traversal after Eeyore remove: \n";
    bt.preorder();

    BinaryTree<string> bt;
    cout << bt << endl;

    return RUN_TEST_OK;
}

程序的输出测试：
Preorder tracersal:
Piglet Eeyore Chris Kanga Roo Pooh Tigger 

Preorder traversal after Piglet remove:   
Roo Pooh Eeyore Chris Kanga Tigger        

Preorder traversal after Eeyore remove:   
Roo Pooh Kanga Chris Piglet Tigger        
Tree:
Roo Pooh Kanga Chris Piglet Tigger

"I'm fine, Dargon !"

按任意键关闭终端。

4 记录

初学习 C++ ，把Essential C++ 学习结束，应该不太适合没有任何语言接触的同学学习，之前有C的基础但是对于作者想在漫不经意中所传达的知识，自己肯定有很多没有get 到的。其实对于语言这种东西还得老老实实的学习不要相信多少多少天完成都是扯淡。学习嘛！沉甸甸的踏实好些。对于新接触的一门语言来说重要的是你要按照它的语法来描述同一样的东西这点是很重要的，其实远远没有到使用逻辑技巧去解决一些实用性的问题暂且把这称作基础吧！
隔几天突然找到问题所在特此回来更改一天天的净写BUG了