<仅是自己做笔记。。。系列-2>求二叉树中节点的最大距离

如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。

写一个程序，求一棵二叉树中相距最远的两个节点之间的距离。

一般我们想到的是，把根节点的左侧最深找出来，再把右侧最深找出来就好了，但是我们会忽视一个问题，比如说，当右侧只有一个节点，左侧内部的深度很深，此时就不能这样了。感觉应该要把每一个节点，都作为根节点来遍历一次，才能得到正确答案。

下面附上我的代码，代码不是很紧凑，但是思想应该表达出来了。

#include <iostream>
#include <algorithm>
using namespace std;
class CTwoTree
{
public:
    struct BSTreeNode
    {
      int m_nValue; // value of node
      BSTreeNode *m_pLeft; // left child of node
      BSTreeNode *m_pRight; // right child of node
    };
    CTwoTree()
    {
        proot = NULL;
        leftMode = true;
        maxCnt = 0;
        leftMax = 0;
        rightMax = 0;
        maxOut = 0;
    }
    void CAddNode(int m_nValue, BSTreeNode * &p)
    {
        if(p == NULL)
        {
            p = new BSTreeNode;
            p->m_nValue = m_nValue;
            p->m_pLeft = NULL;
            p->m_pRight = NULL;
            return;
        }
        if(m_nValue > p->m_nValue)
        {
            CAddNode(m_nValue, p->m_pRight);
        }
        else if(p->m_nValue > m_nValue)
        {
            CAddNode(m_nValue, p->m_pLeft);
        }

    }
    void CAddNode(int m_nValue)
    {
        CAddNode(m_nValue, proot);
    }
    //把此节点作为root，用来找此节点左侧最深的路径加上右侧最深的路径
    void findMaxPath(BSTreeNode * &p, BSTreeNode * &ptmp)
    {
        if(p->m_pLeft == NULL && p->m_pRight == NULL)
        {
            if(leftMode)
                leftMax -= 1;
            else
                rightMax -= 1;
            return;
        }
        if(p->m_pLeft != NULL)
        {
            if(leftMode)
            {
                leftMax += 1;
                if(maxCnt < leftMax)
                    maxCnt = leftMax;
            }
            else
            {
                rightMax += 1;
                if(maxCnt < rightMax)
                    maxCnt = rightMax;
            }


            findMaxPath(p->m_pLeft,ptmp);
        }
        if(p == ptmp)
        {
            //当相等时，说明从左过度到右
            leftMax = maxCnt;
            rightMax = 0;
            maxCnt = 0;
            leftMode = false;
        }

        if(p->m_pRight != NULL)
        {
            if(leftMode)
            {
                leftMax += 1;
                if(maxCnt < leftMax)
                    maxCnt = leftMax;
            }
            else
            {
                rightMax += 1;
                if(maxCnt < rightMax)
                    maxCnt = rightMax;
            }
            findMaxPath(p->m_pRight,ptmp);
        }
        if(leftMode)
            leftMax -= 1;
        else
            rightMax -= 1;

    }
    //用来记录每一个节点作为根节点时的最长路径
    void findMaxPath(BSTreeNode * p)
    {
        if(p->m_pLeft == NULL && p->m_pRight == NULL)
        {
             return;
        }
        //在每次换一个节点时，就清零一下
        leftMax = 0;
        rightMax = 0;
        maxCnt = 0;
        leftMode = true;
        findMaxPath(p,p);
        if(maxOut < maxCnt + leftMax)
            maxOut = maxCnt + leftMax;
        if(p->m_pLeft != NULL)
        {
            leftMax = 0;
            rightMax = 0;
            maxCnt = 0;
            leftMode = true;
            findMaxPath(p->m_pLeft,p->m_pLeft);

            if(maxOut < maxCnt + leftMax)
                maxOut = maxCnt + leftMax;
        }
        if(p->m_pRight != NULL)
        {
            leftMax = 0;
            rightMax = 0;
            maxCnt = 0;
            leftMode = true;
            findMaxPath(p->m_pRight,p->m_pRight);
            if(maxOut < maxCnt + leftMax)
                maxOut = maxCnt + leftMax;
        }

    }
    void findMaxPath()
    {
        findMaxPath(proot);
        cout << maxOut << endl;
    }
    void deleteAll(BSTreeNode * p)
    {
        delete p;
    }
    ~CTwoTree()
    {
        for(vector<BSTreeNode*>::iterator it = path.begin();it != path.end();)
        {
            vector<BSTreeNode*>::iterator oldIt = it;
            oldIt ++;
            delete *it;
            it=oldIt;
        }
        //不知道什么不能用for_each实现，会报错
        //for_each(path.begin(),path.end(),deleteAll);
    }
private:
    int leftMax;
    int rightMax;
    int maxCnt;
    int maxOut;
    bool leftMode;
    BSTreeNode *proot;
    vector<BSTreeNode*> path;
};
int main(int argc, char *argv[])
{
    CTwoTree a;
//    a.CAddNode(10);
//    a.CAddNode(5);
//    a.CAddNode(3);
//    a.CAddNode(7);
//    a.CAddNode(8);
//    a.CAddNode(14);
//    a.CAddNode(12);
//    a.CAddNode(16);
//    a.CAddNode(9);
    a.CAddNode(20);
    a.CAddNode(21);
    a.CAddNode(10);
    a.CAddNode(6);
    a.CAddNode(16);
    a.CAddNode(2);
    a.CAddNode(7);
    a.CAddNode(8);
    a.CAddNode(12);
    a.CAddNode(18);
    a.CAddNode(19);

    a.findMaxPath() ;
    return 0;
}