笔记九:二叉树的创建、递归与非递归版前序、中序、后序查找、树高和节点判断

原创 2016年05月30日 16:23:25

代码:

#include<iostream>
#include<vector>
#include<stack>
using namespace std;


template<typename T>
struct binaryTreeNode{
    T element;
    binaryTreeNode<T>  *leftChild;      //左子树
    binaryTreeNode<T>  *rightChild;     //右子树
    binaryTreeNode() {
        leftChild = rightChild = NULL;
    }
    binaryTreeNode(const T& theElement)
    {
        element = theElement;
        leftChild = rightChild = NULL;
    }
    binaryTreeNode(const T&  theElement, binaryTreeNode *theLeftChild, binaryTreeNode *theRightChild)
    {
        element(theElement);
        leftChild = theLeftChild;
        rightChild = theRightChild;
    }
};

template <typename T>
class binaryTree{
public:
    virtual ~binaryTree() {}
    virtual bool empty() const = 0;
    virtual int size() const = 0;
    virtual void visit(T *) const = 0;
    virtual void InputBinaryNode() = 0;
    virtual void preCreateBinaryTree(T *&) = 0;

    /*virtual void preOrder(binaryTreeNode<T> *node) = 0;
    virtual void inOrder(binaryTreeNode<T> *node) = 0;
    virtual void postOrder(binaryTreeNode<T> *node) = 0;

    virtual void Iter_preOrder(binaryTreeNode<T> *node) = 0;
    virtual void Iter_inOrder(binaryTreeNode<T> *node) = 0;
    virtual void Iter_postOrder(binaryTreeNode<T> *node) = 0;*/
    virtual void preOrder(T *) = 0;
    virtual void inOrder(T *) = 0;
    virtual void postOrder(T *) = 0;

    virtual void Iter_preOrder(T *) = 0;
    virtual void Iter_inOrder(T *) = 0;
    virtual void Iter_postOrder(T *) = 0;


};

template<typename E>
class linkedBinaryTree : public binaryTree<binaryTreeNode<E> >
{
public:
    linkedBinaryTree(){ root = NULL; treeSize = 0; }
    ~linkedBinaryTree() {};
    bool empty() const { return treeSize == 0; }
    int size() const { return treeSize; }
    void visit(binaryTreeNode<E> *node) const;
    void InputBinaryNode();
    void preCreateBinaryTree(binaryTreeNode<E> *&node);
    int height(binaryTreeNode<E> *&node) const;

    void preOrder(binaryTreeNode<E> *node);
    void inOrder(binaryTreeNode<E> *node);
    void postOrder(binaryTreeNode<E> *node);

    void Iter_preOrder(binaryTreeNode<E> *node);
    void Iter_inOrder(binaryTreeNode<E> *node);
    void Iter_postOrder(binaryTreeNode<E> *node);


private:
    binaryTreeNode<E> *root;
    int treeSize;
    vector<E> vecNode;
};

template<typename E>
void linkedBinaryTree<E>::visit(binaryTreeNode<E> *node) const
{
    //访问节点*node, 仅输出element
    cout << node->element << " ";
}

template<typename E>
void linkedBinaryTree<E>::InputBinaryNode()
{
    E elem;
    cout << "!!!注意:(1)#表示空节点;(2)请在输入的字符串末尾加0,作为输入结束的标志!" << endl;
    while (cin >> elem && elem != '0')
    {
        vecNode.push_back(elem);
    }
}

template<typename E>
void linkedBinaryTree<E>::preCreateBinaryTree(binaryTreeNode<E> *&node)
{
    vector<E>::iterator it = vecNode.begin();
    if (it != vecNode.end())
    {
        if (*it == '#')
        {
            node = NULL;
            vecNode.erase(it);
        }
        else{
            node = new binaryTreeNode<E>(*it);  //生成根节点
            treeSize++;
            vecNode.erase(it);
            preCreateBinaryTree(node->leftChild);   //构造左子树
            preCreateBinaryTree(node->rightChild);  //构造右子树
        }
    }
    else{
        node = NULL;
    }
}

template<typename E>
int linkedBinaryTree<E>::height(binaryTreeNode<E> *&node) const
{
    if (!node)
    {
        return 0;
    }

    int hl = height(node->leftChild);   //左子树的高
    int hr = height(node->rightChild);  //右子树的高
    if (hl > hr)
    {
        return ++hl;
    }
    else{
        return ++hr;
    }

}

template<typename E>
void linkedBinaryTree<E>::preOrder(binaryTreeNode<E> *node)
{
    //根节点——左子树——右子树
    if (node)
    {
        visit(node);
        preOrder(node->leftChild);
        preOrder(node->rightChild);
    }

}

template<typename E>
void linkedBinaryTree<E>::inOrder(binaryTreeNode<E> *node)
{
    //左子树——根节点——右子树 
    if (node)
    {
        inOrder(node->leftChild);
        visit(node);
        inOrder(node->rightChild);
    }

}

template<typename E>
void linkedBinaryTree<E>::postOrder(binaryTreeNode<E> *node)
{
    //左子树——右子树——根节点
    if (node)
    {
        postOrder(node->leftChild);
        postOrder(node->rightChild);
        visit(node);
    }

}

template<typename E>
void linkedBinaryTree<E>::Iter_preOrder(binaryTreeNode<E> *node)
{
    stack<binaryTreeNode<E>* > stk;     //存储树节点
    binaryTreeNode<E> * currNode = node;
    while (currNode || (!stk.empty()))
    {
        if (currNode)
        {
            visit(currNode);            //访问根节点
            stk.push(currNode);
            currNode = currNode->leftChild; //遍历左子树
        }
        else{
            currNode = stk.top();       //节点入栈前已被访问,故无需再次访问
            stk.pop();
            currNode = currNode->rightChild;
        }
    }

}

template<typename E>
void linkedBinaryTree<E>::Iter_inOrder(binaryTreeNode<E> *node)
{
    stack<binaryTreeNode<E>* > stk;
    binaryTreeNode<E>* currNode = node;
    while (currNode || (!stk.empty()))
    {
        if (currNode)
        {
            stk.push(currNode);     //先将左子树全部压入栈
            currNode = currNode->leftChild;
        }
        else{
            currNode = stk.top();
            stk.pop();
            visit(currNode);        //访问根节点
            currNode = currNode->rightChild;
        }
    }
}

template<typename E>
void linkedBinaryTree<E>::Iter_postOrder(binaryTreeNode<E> *node)
{
    stack<binaryTreeNode<E>* > stk;
    binaryTreeNode<E>* currNode = node, *rightNode = node;
    while (currNode || (!stk.empty()))
    {
        if (currNode)
        {
            stk.push(currNode);     //遍历左子树
            currNode = currNode->leftChild;
        }
        else{
            currNode = stk.top();
            currNode = currNode->rightChild;    //遍历右子树
            if (!currNode)          //此时栈顶元素的左孩子、右孩子均为空,即为叶子节点
            {
                rightNode = stk.top();
                stk.pop();
                visit(rightNode);   //访问叶子节点
                //若刚被访问的叶子节点是此时栈顶元素的右孩子,则说明左、右子树均被遍历完
                //循环的目的是为了找到最终的父结点,当前所有已访问的节点是作为其左子树的节点而存在
                while ((!stk.empty()) && (stk.top()->rightChild == rightNode))
                {
                    rightNode = stk.top();  //由于该节点的右节点已被访问,说明完成了左右子树的遍历
                    stk.pop();
                    visit(rightNode);       //叶子节点已经被访问,则最后访问根节点
                }
                if (!stk.empty())           //刚被访问的是此时栈顶元素的左孩子,则右孩子还未入栈
                {
                    currNode = stk.top();
                    currNode = currNode->rightChild;
                }
            }
        }//else
    }
}

int main(int argc, char* argv[])
{
    linkedBinaryTree<char> LBT;
    binaryTreeNode<char>* root;
    LBT.InputBinaryNode();
    LBT.preCreateBinaryTree(root);
    cout << "二叉树的总节点数为:" << LBT.size() << endl;
    cout << "二叉树的高度为:"<< LBT.height(root) << endl;

    cout << "\n前序遍历二叉树(递归):" << endl;
    LBT.preOrder(root);
    cout << "\n中序遍历二叉树(递归):" << endl;
    LBT.inOrder(root);
    cout << "\n后序遍历二叉树(递归):" << endl;
    LBT.postOrder(root);

    cout << "\n\n前序遍历二叉树(非递归):" << endl;
    LBT.Iter_preOrder(root);
    cout << "\n中序遍历二叉树(非递归):" << endl;
    LBT.Iter_inOrder(root);
    cout << "\n后序遍历二叉树(非递归):" << endl;
    LBT.Iter_postOrder(root);

    return 0;
}

注:中间注释代码部分会造成,纯虚函数没有强制替代项的错误。

结果 :
这里写图片描述

注:上述代码是在我的旧文基础上改进的http://blog.csdn.net/u014033518/article/details/38844583

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

二叉树的构建并没有任何功能.

#include #include using namespace std;  template  struct TreeNode{   T data;   TreeNode* left;  ...

C++实现链式二叉树,采用非递归的方式先序,中序,后序遍历二叉树

转自 http://blog.csdn.net/yushuai007008/article/details/7101663 如有不足之处,还望指正! [cpp] view pl...

1110. Complete Binary Tree (25) -- 完全二叉树相关性质, 求树根两种方法

题目地址https://www.patest.cn/contests/pat-a-practise/1110题目描述Given a tree, you are supposed to tell if ...

二叉树的创建与前序、中序和后序的递归与非递归调用

#include #include #include #include using namespace std; typedef char ElemType; class BiTNode { fr...

二叉树的深度优先dfs遍历(前序、中序和后序;递归与非递归)

二叉树本身就是用递归定义的,因此采用递归方法实现dfs的三种遍历不仅容易理解而且代码简洁。 若用非递归实现,则要采用栈去模拟:保存计算的上下文,使得计算在返回上一级时有路可循。注意每一个结点都要当...
  • mach7
  • mach7
  • 2014年02月26日 15:18
  • 4560

二叉树的中序、后序、前序的递归与非递归输出

#include "stdafx.h" #include #include #include using namespace std; typedef struct TreeNode ...

二叉树系列(建树,前序,中序,后序,中序非递归,深度,叶子数,节点数)

二叉树                                          a                                      /       \       ...

二叉排序树的创建,删除结点;树的前序,中序,后序非递归遍;二叉树的线索化

#include #include using namespace std; typedef int ELEMENT_TYPE; //定义树的结点 typedef struct Node{ ELEM...

二叉树遍历(前序、中序、后序)递归与非递归

二叉树的非递归遍历                                                             二叉树的非递归遍历          二叉树是一种非...
  • pupuzay
  • pupuzay
  • 2015年09月19日 20:49
  • 137
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:笔记九:二叉树的创建、递归与非递归版前序、中序、后序查找、树高和节点判断
举报原因:
原因补充:

(最多只允许输入30个字)