有关二叉树的遍历问题

在数据结构中，有个很重要的概念就是树。而二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。

在一些二叉树的应用中，常常要求在树中查找某种特征的结点，或是对树中全部结点逐一进行某种处理，这时候就需要遍历二叉树。遍历二叉树指的是，按某条搜索路径巡访树中的每个结点，使得每个结点均被访问一次，且仅被访问一次。

在二叉树的遍历中最常见的遍历有三种：前序遍历、中序遍历、后序遍历。当然在遍历之前我们首先得有棵二叉树。那么如何建立一棵二叉树。根据二叉树的特点，我们采用二叉链表存储，用一个结构体保存二叉树结点，如下。

template<class T>
struct BinaryTreeNode
{
    BinaryTreeNode<T>* _left;   //左孩子结点
    BinaryTreeNode<T>* _right;  //右孩子结点
    T _data;      //存储的数据

    BinaryTreeNode(const T& x)
        :_data(x)
        , _left(NULL)
        , _right(NULL)
    {}
};

下来我们直接进入主题，怎么对一个二叉树进行前序遍历、中序遍历、后序遍历。下图是一个简单的二叉树，遍历依次经过的结点也已经标注了。下边我们直接上代码进行遍历。

1.前序遍历

因为前序遍历是先遍历根，所以我们每次遍历根，就打印出根结点存储的数据。然后针对每个子树，可以在分解成根和它的左子树和右子树。

    void _PrevOrder(Node* root)
    {
        if (root == NULL) return;
        cout << root->_data << " ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }

2.中序遍历
中序遍历的特点是先遍历左子树，然后再遍历根，最后是右子树。把每一个结点都当作一个树去处理，每一次都是先去访问它的左子树。

    void _InOrder(Node* root)
    {
        if (root == NULL) return;
        _InOrder(root->_left);
        cout << root->_data << " ";
        _InOrder(root->_right);
    }

3.后序遍历
后序遍历是先访问左子树，接着是右子树，最后才是根。处理方法和上面比较类似，就不过多赘余了。

    void _PostOrder(Node* root)
    {
        if (root == NULL) return;
        _PostOrder(root->_left);
        _PostOrder(root->_right);
        cout << root->_data << " ";
    }

总结一下，二叉树的遍历结点，无论是前序、中序还是后序，它处理的方法都是把一个树分解成它的某个子树，然后在把这个子树看成一个树去寻找它的某个结点。

当然在二叉树中，我们也可能遇到求叶子结点啊，求某层有多少个结点的类似问题。比如，现在求解上面那棵树的所有叶子结点的个数。如果直接求叶子结点，可能无从下手，那么我们先求根结点的叶子节点，再去求根节点的叶子结点的叶子结点……不断把结点去细化。叶子结点是一棵树中没有子结点的结点，所以我们的判断条件是”root->_left == NULL && root->_right == NULL“。按照这个思路就有以下代码。

    size_t _GetLeafSize(Node* root)
    {
        if (root == NULL) return 0;
        if (root->_left == NULL && (root->_right == NULL)) return 1;
        return _GetLeafSize(root->_left) + _GetLeafSize(root->_right);
    }

同理，如果求二叉树中第K层的结点数。我们也可以按照这种递归的思路去进行求解。我们先求解出K-1层有多少个结点，然后依次求解。代码如下。

    size_t _GetKLevelSize(Node* root, size_t k)
    {
        if (root == NULL) return 0;
        if (k == 0) return 1;
        return _GetKLevelSize(root->_left, k - 1) + _GetKLevelSize(root->_right, k - 1);
    }

其实只要和二叉树有关的问题，我们用到最多的就是遍历，然后选出符合条件的结点。关于二叉树的遍历问题，一定要把握好它求解的精髓——递归思想，把一个大问题无限地缩小，变成它的子问题。子问题的求解就十分简单了，然后在一层层返回，从而解决大问题。

源代码如下：

#include<iostream>
#include<queue>
using namespace std;

template<class T>
struct BinaryTreeNode
{
    BinaryTreeNode<T>* _left;
    BinaryTreeNode<T>* _right;
    T _data;

    BinaryTreeNode(const T& x)
        :_data(x)
        , _left(NULL)
        , _right(NULL)
    {}
};

template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree()
        :_root(NULL)
    {}

    ~BinaryTree()
    {}

    BinaryTree(T* a, size_t n, const T& invalid = T())
    {
        size_t index = 0;
        _root=_CreatTree(a, n, invalid, index);
    }

    void PrevOrder()
    {
        cout << "PrevOrder:";
        _PrevOrder(_root);
        cout << endl;
    }

    void InOrder()
    {
        cout << "InOrder:";
        _InOrder(_root);
        cout << endl;
    }

    void PostOrder()
    {
        cout << "PostOrder:";
        _PostOrder(_root);
        cout << endl;
    }

    void LevelOrder()
    {
        cout << "LevelOrder:";
        queue<Node*> q;
        if (_root)
            q.push(_root);
        while (!q.empty())
        {
            Node* tmp = q.front();
            cout << tmp->_data << " ";
            q.pop();
            if (tmp->_left)  q.push(tmp->_left);
            if (tmp->_right) q.push(tmp->_right);
        }

        cout << endl;
    }

    size_t Size()
    {
        return _Size(_root);
    }

    size_t GetLeafSize()
    {
        return _GetLeafSize(_root);
    }

    size_t GetKLevelSize(size_t k)
    {
        return _GetKLevelSize(_root, k);
    }

protected:
    Node*   _CreatTree(T* a, size_t n, const T& invalid, size_t& index)
    {
        Node* root = NULL;
        if (index < n && a[index] != invalid)
        {
            root = new Node(a[index]);
            root->_left = _CreatTree(a, n, invalid, ++index);
            root->_right = _CreatTree(a, n, invalid, ++index);
        }
        return root;
    }

    void _PrevOrder(Node* root)
    {
        if (root == NULL) return;
        cout << root->_data << " ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }

    void _InOrder(Node* root)
    {
        if (root == NULL) return;
        _InOrder(root->_left);
        cout << root->_data << " ";
        _InOrder(root->_right);
    }

    void _PostOrder(Node* root)
    {
        if (root == NULL) return;
        _PostOrder(root->_left);
        _PostOrder(root->_right);
        cout << root->_data << " ";
    }

    size_t _Size(Node* root)
    {
        if (root == NULL) return 0;
        return _Size(root->_left) + _Size(root->_right)+1;
    }

    size_t _GetLeafSize(Node* root)
    {
        if (root == NULL) return 0;
        if (root->_left == NULL && (root->_right == NULL)) return 1;
        return _GetLeafSize(root->_left) + _GetLeafSize(root->_right);
    }

    size_t _GetKLevelSize(Node* root, size_t k)
    {
        if (root == NULL) return 0;
        if (k == 0) return 1;
        return _GetKLevelSize(root->_left, k - 1) + _GetKLevelSize(root->_right, k - 1);
    }

protected:
    Node* _root;
};


void TestBinaryTree()
{
    int array[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
    BinaryTree<int> t(array, 10, '#');
    t.PrevOrder();
    t.InOrder();
    t.PostOrder();
    t.LevelOrder();
    cout<<"Size:"<<t.Size()<<endl;
    cout << "LeafSize:" << t.GetLeafSize() << endl;
    cout << "k层的节点数:" << t.GetKLevelSize(2) << endl;
}