二叉树其他操作（复制，层数，相等判断）

1.二叉树复制

//复制一棵二叉树
template<class T> tree<T>::tree(const tree<T> &obj)
{

    this->root=copy(obj.root);
}

template<class T> tree<T>& tree<T>::operator=(const tree<T> &obj)
{
    if (this!=&obj)
    {
        this->root=copy(obj.root);
    }

    return *this;

}

template<class T> tree_node<T> * tree<T>::copy(const tree_node<T> *p)
{
    if (p)
    {
        tree_node<T> *node=new tree_node<T>;
        if (node==NULL)
        {
            cout<<"out of member"<<endl;
            exit(1);
        }
        node->value=p->value;
        node->lchild=copy(p->lchild);
        node->rchild=copy(p->rchild);
        return node;
    }
    else
        return NULL;
}

2.统计节点数

//统计节点数
template<class T> int tree<T>::nodes()
{
    int count=0;

    //中序遍历
    if (root)
    {
        tree_node<T> *ptr=root;
        stack<tree_node<T> *> stack;

        while (1)
        {
            while (ptr)
            {
                stack.push(ptr);
                ptr=ptr->lchild;
            }    
            
            if (stack.isEmpty())
            {
                break;
            }
            ptr=stack.Top();
            stack.pop();
            count++;
            
            ptr=ptr->rchild;
        }
    }
    
    return count;
}

3.交换左右子树

//交换左右子树
template<class T> void tree<T>::swap_tree()
{
    swap(this->root);
}

template<class T> void tree<T>::swap(tree_node<T> *p)
{
    if (p)
    {
        tree_node<T> *temp;
        temp=p->lchild;
        p->lchild=p->rchild;
        p->rchild=temp;
        swap(p->lchild);
        swap(p->rchild);
    }
}

4.获得树层数

//获得树层数
template<class T> int tree<T>::depth()
{
    return get_depth(root);
}

template<class T> int tree<T>::get_depth(tree_node<T> *p)
{
    if(p)
    {
        int left_depth=get_depth(p->lchild);
        int rigth_depth=get_depth(p->rchild);

        if (left_depth<=rigth_depth)
            return rigth_depth+1;
        else
            return left_depth+1;
    }
    else
        return 0;    //空树
}