【二叉树】二叉树的高度以及创建 销毁二叉树

更多的二叉树题 二叉树面试题

二叉树的高度

分析：求二叉树的高度，可以用递归的思想，先求出左子树的高度，再求出右子树的高度，然后取他们的最大值+1。

递归求二叉树的高度

int GetHight(Node *pRoot)
{
  if(pRoot == NULL)
      return 0;
  if(pRoot->left == NULL || pRoot->right == NULL)
      return 1;
  int lHight = GetHight(pRoot->left);
  int rHight = GetHight(pRoot->right);
  return (LHeigt > RHeight) ? (LHeigt + 1) : (RHeight + 1);  
}

非递归求二叉树高度
分析：利用层次遍历，统计遍历了几次二叉树。

 /* 层次遍历的非递归版本 */
    int maxDepthWithLevelTraversal(TreeNode* root){
        /* 判断树是否为空 */
        if(!root){
            return 0;
        }

        int height = 0;    // 初始化树的高度为0

        queue<TreeNode*>Q;  // 初始化一个队列，并将根节点入队
        Q.push(root);

        /* 当队列不为空时 */
        /* 实际上当每次循环开始时，队列中存储的刚好是将要访问下一层的所有元素*/
        while(!Q.empty()){
            height++;
            int curLevelSize = Q.size();  // 记录当前层元素个数
            int cnt = 0;
            /* 弹出当前层所有元素 */
            while(cnt < curLevelSize){
                TreeNode* temp = Q.front();
                Q.pop();
                cnt++;
                /* 将下一层的元素入队列 */
                if(temp->left){
                    Q.push(temp->left);
                }
                if(temp->right){
                    Q.push(temp->right);
                }
            }
        }
        return height;
    }

非递归求二叉树

//利用非递归的后序遍历,求出每次栈的大小，最大值即为高度
size_t GetHight(Node* pNode)
{
    if (pNode == NULL)
        return 0;
    stack<Node*> s;
    Node *p = pNode;
    Node *pre = NULL;
    size_t hight = 0;
    while (p || !s.empty())
    {
        while (p)
        {
            s.push(p);
            p = p->left;
        }
        //栈的最大的值为高度
        size_t size = s.size();
        hight = size > hight ? size : hight;
        Node* pTop = s.top();
        if (pTop->right == NULL || pTop->right == pre)
        {
            pre = pTop;
            s.pop();
        }
        else
        {
            p = pTop->right;
        }
    }
    return hight;
}

创建二叉树
思路：已前序遍历的特点来创建二叉树，如果没有左右孩子就用”#”来表示
注意：递归调用时_CreatBinaryTree()的参数pRoot 和index数组下标为引用，

BinaryTree(const T array[], size_t size)  
    :_pRoot(NULL)  
{  
    size_t index = 0;  
    _CreatBinaryTree(_pRoot, array, size, index);  
}  
void _CreatBinaryTree(BinaryTreeNode<T>*& pRoot,const T array[], size_t size, size_t& index)   
{   
    if (index < size && '#' != array[index])  
    {  
        pRoot = new BinaryTreeNode<T>(array[index]);  
        _CreatBinaryTree(pRoot->_pLeftChild,array,size,++index);  
        _CreatBinaryTree(pRoot->_pRightChild,array,size,++index);  
    }  
}

销毁二叉树

思路：采用递归的方法，从下往上 销毁，最后销毁根节点。

void _DestoryBinaryTree(BinaryTreeNode<T>*& pRoot)
    {
        if (pRoot)
        {
            _DestoryBinaryTree(pRoot->_pLeftChild);
            _DestoryBinaryTree(pRoot->_pRightChild);
            delete pRoot;
            pRoot = NULL;
        }
    }