数据结构——二叉树的基本操作

二叉树节点结构

template<class T>struct BinaryTreeNode{    BinaryTreeNode(const T& data)        :_data(data)        ,_pLeft(NULL)        ,_pRight(NULL)    {}    T _data;    BinaryTreeNode<T>* _pLeft;    BinaryTreeNode<T>* _pRight;};

二叉树的构造

template<class T>class BinaryTree{    typedef BinaryTreeNode<T> Node;public:    //构造函数    BinaryTree()        :_pRoot(NULL)    {}    BinaryTree(const T array[], size_t size, const T& invalid)    {        size_t index = 0;        _CreateTree(_pRoot, array, size, index, invalid);    }    //拷贝构造函数    BinaryTree(const BinaryTree<T>& t)    {        _pRoot = _CopyBinaryTree(t._pRoot );    }    //赋值运算符重载    BinaryTree<T>& operator=(const BinaryTree<T>& t)    {        //先销毁当前对象，再拷贝        _DestroyTree(t._pRoot );        _CopyBinaryTree(t._pRoot );    }    ~BinaryTree()    {        _DestroyTree(_pRoot);    }    private:    void _CreateTree(Node*& pRoot, const T array[], size_t size, size_t& index, const T& invalid)    {        if(index < size&&array[index] != invalid)        {            pRoot = new Node(array[index]);            _CreateTree(pRoot->_pLeft ,array,size,++index,invalid);            _CreateTree(pRoot->_pRight ,array,size,++index,invalid);        }    }    Node* _CopyBinaryTree(Node* pRoot)    {        if(NULL != pRoot)        {            Node* pNew = new Node(pRoot->_data);            pNew->_pLeft = _CopyBinaryTree(pRoot->_pLeft );            pNew->_pRight = _CopyBinaryTree(pRoot->_pRight );            return pNew;        }        return NULL;    }    void _DestroyTree(Node* pRoot)    {        if(pRoot)        {            _DestroyTree(pRoot->_pLeft );            _DestroyTree(pRoot->_pRight );            delete pRoot;            pRoot = NULL;        }    }private:    BinaryTreeNode<T>* _pRoot;};

二叉树遍历——递归

public:    // 先序遍历——递归    void PreOrder()    {        cout<<"PreOrder()"<<endl;        _PreOrder(_pRoot);        cout<<endl;    }    // 中序遍历——递归    void InOrder()    {        cout<<"InOrder()"<<endl;        _InOrder(_pRoot);        cout<<endl;    }        // 后续遍历——递归    void PostOrder()    {        cout<<"PostOrder()"<<endl;        _PostOrder(_pRoot);        cout<<endl;    }private:    void _PreOrder(Node* pRoot)    {        if(pRoot)        {            cout<<pRoot->_data <<" ";            _PreOrder(pRoot->_pLeft );            _PreOrder(pRoot->_pRight );        }    }    void _InOrder(Node* pRoot)    {        if(pRoot)        {            _InOrder(pRoot->_pLeft );            cout<<pRoot->_data <<" ";            _InOrder(pRoot->_pRight );        }    }    void _PostOrder(Node* pRoot)    {        if(pRoot)        {            _PostOrder(pRoot->_pLeft );            _PostOrder(pRoot->_pRight );            cout<<pRoot->_data <<" ";        }    }

二叉树遍历——非递归

//先序遍历    void _PreOrder_Nor(Node* pRoot)    {        if(pRoot)        {            stack<Node*> s;            Node* pCur = pRoot;            s.push(pCur);            while(!s.empty())            {                pCur = s.top();                cout<<pCur->_data <<" ";                s.pop();                if(pCur->_pRight )                    s.push(pCur->_pRight );                if(pCur->_pLeft )                    s.push(pCur->_pLeft );            }        }    }//中序遍历    void _InOrder_Nor(Node* pRoot)    {        stack<Node*> s;        Node* pCur = pRoot;        while(pCur || !s.empty())        {            while(pCur)            {                s.push(pCur);                pCur = pCur->_pLeft ;            }            pCur = s.top();            cout<<pCur->_data <<" ";            s.pop();            pCur = pCur->_pRight ;            //while(NULL == pCur->_pRight )            //{            //  pCur = s.top();            //  cout<<pCur->_data <<" ";            //  s.pop();            //}            //pCur = pCur->_pRight ;        }    }//后序遍历    void _PostOrder_Nor(Node* pRoot)    {        stack<Node*> s;        Node* pCur = pRoot;//指向根节点        Node* pPre = NULL;//指向已经访问过的节点        Node* pTop = NULL;//指向栈顶节点        while(pCur || !s.empty())        {            while(pCur)            {                s.push(pCur);                pCur = pCur->_pLeft ;            }            pTop = s.top();            //当节点右子树为空或当前右节点已经访问过，则对该节点进行访问            if(pTop->_pRight == NULL || pPre == pTop->_pRight )            {                cout<<pTop->_data <<" ";                pPre = pTop;                s.pop();            }            //转换为子问题            else                pCur = pTop->_pRight ;            //注意是pCur是指向栈顶节点的右节点        }    }

二叉树层序遍历

// 层序遍历    void LevelOrder()    {        cout<<" LevelOrder()"<<endl;        queue<Node*> q;//申请一个保存二叉树节点的队列        Node* pCur = NULL;        if(NULL != _pRoot)        {            q.push (_pRoot);            while(!q.empty ())            {                pCur = q.front ();                cout<<pCur->_data <<" ";                if(pCur->_pLeft )                    q.push (pCur->_pLeft );                if(pCur->_pRight )                    q.push (pCur->_pRight );                q.pop ();            }        }        cout<<endl;    }

二叉树面试题
求镜像二叉树

public:    //求某一二叉树的镜像——递归    void GetBinaryMirror()    {        _GetBinaryMirror(_pRoot);    }    //求某一二叉树的镜像——非递归    void GetBinaryMirror_Nor()    {        _GetBinaryMirror_Nor(_pRoot);    }        void _GetBinaryMirror(Node* pRoot)    {        if(pRoot)        {            std::swap (pRoot->_pLeft ,pRoot->_pRight );            _GetBinaryMirror(pRoot->_pLeft );            _GetBinaryMirror(pRoot->_pRight );        }    }private:    void _GetBinaryMirror_Nor(Node* pRoot)    {        queue<Node*> q;        q.push(pRoot);        while(!q.empty())        {            Node* pCur = q.front();            std::swap (pCur->_pLeft ,pCur->_pRight );            if(pCur->_pLeft )                q.push(pCur->_pLeft );            if(pCur->_pRight )                q.push(pCur->_pRight );            q.pop();        }    }

判断一棵树是不是完全二叉树

    //判断一颗树是否为完全二叉树    bool IsCompleteBinaryTree()    {        bool flag = true;//判断一棵子树是否为一棵二叉树的标记        queue<Node*> q;//运用队列进行层序遍历        q.push(_pRoot);        while(!q.empty())        {            Node* pCur = q.front();            q.pop();            //如果队首元素的左子树为空将标记置为false如果层序遍历后面的节点还有子树说明不是            if(NULL == pCur->_pLeft )                flag = false;            else            {                //如果falg为假，说明之前已经有节点的孩子为空，又因当前节点的左孩子不为空，说明不是                if(flag == false)                    return false;                q.push(pCur->_pLeft );            }            //如果队首元素的右树为空，将标记置为false如果层序遍历后面的节点还有子树，说明不是            if(NULL == pCur->_pRight )                flag = false;            else            {                //如果flag为假说明之前已经有节点的孩子为空，又因当前节点的右孩子不为空说明不是                if(flag == false)                    return false;                q.push(pCur->_pRight );            }        }        return true;    }

public:    //找双亲节点    Node* GetParent(T& value)    {        Node* x = Find(value);        return _GetParent(_pRoot,x);    }private:        Node* _GetParent(Node* pRoot,Node* x)    {        if(pRoot == NULL||x == NULL||pRoot == x)            return NULL;        if(x == pRoot->_pLeft || x == pRoot->_pRight )            return pRoot;        Node* pLeft = _GetParent(pRoot->_pLeft ,x);        Node* pRight = _GetParent(pRoot->_pRight ,x);    }

public:    //判断某节点是否存在    Node* Find(const T& value)    {        return _Find(_pRoot,value);    }private:    Node* _Find(Node* pRoot,const T& value)    {        if(NULL == pRoot)            return NULL;        if(pRoot->_data == value)            return pRoot;        Node* pCur = _Find(pRoot->_pLeft ,value);        if(pCur)            return pCur;        return _Find(pRoot->_pRight ,value);    }

    //获得某节点的左孩子    Node* GetLeftChild(Node* pCur)    {        return (NULL == pCur)?NULL:pCur->_pLeft ;    }    //获得某节点的右孩子    Node* GetRightChild(Node* pCur)    {        return (NULL == pCur)?NULL:pCur->_pRight ;    }

    //计算二叉树的高度    size_t Height()    {        return _Height(_pRoot);    }    size_t _Height(Node* pRoot)    {        if(NULL == pRoot)            return 0;        if(NULL == pRoot->_pLeft && NULL == pRoot->_pRight )            return 1;        size_t hLeft = _Height(pRoot->_pLeft );        size_t hRight = _Height(pRoot->_pRight );        return hLeft>hRight?hLeft+1:hRight+1;    }

    //计算叶子节点的个数    size_t GetLeafNode()    {        return _GetLeafNode(_pRoot);    }    size_t _GetLeafNode(Node* pRoot)    {        if(NULL == pRoot)            return 0;        if(NULL == pRoot->_pLeft && NULL == pRoot->_pRight )            return 1;        return _GetLeafNode(pRoot->_pLeft )+_GetLeafNode(pRoot->_pRight );    }

    //计算第K层的节点数    size_t GetKLevelNode(size_t k)    {        return _GetKLevelNode(_pRoot, k);    }    size_t _GetKLevelNode(Node* pRoot,size_t k)    {        if(NULL == pRoot && k<1 && k>_Height(pRoot))            return 0;        if(k == 1)            return 1;        size_t kLeft = _GetKLevelNode(pRoot->_pLeft ,k-1);        size_t kRight = _GetKLevelNode(pRoot->_pRight ,k-1);        return kLeft + kRight;    }