码海拾遗：二叉树的遍历（递归实现）

　　二叉树是一种特殊的树结构：每个节点最多有两个子节点。

　　二叉树的性质：

　　（1）二叉树第i层的节点数目最多为 2^{i-1} (i≥1)。

　　（2）深度为k的二叉树至多有2^{k}-1个结点(k≥1)。

　　（3）包含n个结点的二叉树的高度至少为log₂ (n+1)。

　　（4）在任意一棵二叉树中，若终端结点的个数为n₀，度为2的结点数为n₂，则n₀=n₂+1。

实现：

bitTree.h

#pragma once

#include <iostream>

struct tree
{
    int data;
    tree *liftChild, *rightChild;
};

class bitTree
{
public:
    bitTree();
    ~bitTree();

    void insertTree(int data);

    //前序遍历
    void preorder(tree *p);
    //中序遍历
    void interthem(tree *p);
    //后序遍历
    void postorder(tree *p);

    //计算二叉树节点数
    int count(tree *p);
    //统计叶子节点数
    int findLeafNum(tree *p);

    //获取二叉树根节点
    tree *getRoot();

    static int leafNum;

private:
    tree *root;
};

bitTree.cpp

int bitTree::leafNum = 0;

bitTree::bitTree()
{
    root = NULL;
}


bitTree::~bitTree()
{
}

void bitTree::insertTree(int data)
{
    tree *newTree = new tree;
    newTree->data = data;
    newTree->liftChild = newTree->rightChild = NULL;

    if (NULL == root)
        root = newTree;
    else
    {
        tree *backup = NULL;
        tree *current = root;
        while (current != NULL)
        {
            backup = current;
            if (current->data > data)
                current = current->liftChild;
            else
                current = current->rightChild;
        }
        if (backup->data > data)
            backup->liftChild = newTree;
        else
            backup->rightChild = newTree;
    }
}

void bitTree::preorder(tree * p)
{
    if (p != NULL)
    {
        std::cout << p->data << " ";
        preorder(p->liftChild);
        preorder(p->rightChild);
    }
}

void bitTree::interthem(tree * p)
{
    if (p != NULL)
    {
        interthem(p->liftChild);
        std::cout << p->data << " ";
        interthem(p->rightChild);
    }
}

void bitTree::postorder(tree * p)
{
    if (p != NULL)
    {
        postorder(p->liftChild);
        postorder(p->rightChild);
        std::cout << p->data << " ";
    }
}

int bitTree::count(tree *p)
{
    if (NULL == p)
        return 0;
    else
        return count(p->liftChild) + count(p->rightChild) + 1;
}

int bitTree::findLeafNum(tree *p)
{
    if (NULL == p)
        return 0;
    else
    {
        if (p->liftChild == NULL && p->rightChild == NULL)
            return leafNum += 1;
        else
        {
            findLeafNum(p->liftChild);
            findLeafNum(p->rightChild);
        }
        return leafNum;
    }
}

tree * bitTree::getRoot()
{
    return root;
}