二叉树常用算法总结

　　最近在复习算法，做了一下编程之美上面关于二叉树的三道题，感觉顺便就把二叉树总结下算了，于是就有了这篇文章，这些算法有些是自己思考出来的，比如重建二叉树，有些是以前的知识还有些是看了网上其它大牛总结而成，现在贴出来分享，希望大家指正。感觉算法的学习重要的不是算法本身而是算法背后的思想，就是一些本质上的东西，或者说思考的过程，这些才是真正重要的。对于二叉树来说，最重要的是它的递归特性，这是由它的定义决定的。写了这么多二叉树的算法，思考了下，对于二叉树的相关问题，首先要考虑的就是是否能应用它的递归性质。

 

　　

//////////////////////////////////////////////////////////////////////////
//                    二叉树相关算法总结
//                        2010.10.22
//
//                        By HappyAngel
//            这里的算法部分来自自己的思考原创，部分来自对网上的总结，收获不少。
//////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <stack>
#include <cstdlib>
#include <queue>

using namespace std;


typedef struct TreeNode
{
    TreeNode* pLeftNode;
    TreeNode* pRightNode;
    char nodeName;
    bool flag;   //for post-order traverse
    int level;    //for level traverse
}TreeNode, * PTreeNode;


//recurisively create binary tree
PTreeNode CreateBinaryTree(void)
{
    char c;
    cin>>c;

    PTreeNode pRoot;

    if('#' == c)
    {
        return NULL;
    }
    else
    {
        pRoot = new TreeNode;
        pRoot->nodeName = c;
        pRoot->flag = false;
        pRoot->level = 0;
        pRoot->pLeftNode = CreateBinaryTree();
        pRoot->pRightNode = CreateBinaryTree();
    }

    return pRoot;
}

void DeleteTree(PTreeNode pRoot)
{
    if(NULL != pRoot)
    {
        DeleteTree(pRoot->pLeftNode);
        DeleteTree(pRoot->pRightNode);
        delete pRoot;
    }
}

void access(const TreeNode& node)
{
    cout<<node.nodeName<<" ";
}

//recursely preorder
void PreOrderTraverse(PTreeNode pNode)
{
    if(pNode != NULL)
    {
        access(*pNode);
        PreOrderTraverse(pNode->pLeftNode);
        PreOrderTraverse(pNode->pRightNode);
    }

}

//recursively inorder
void InOrderTraverse(PTreeNode pNode)
{
    if(pNode != NULL)
    {
        InOrderTraverse(pNode->pLeftNode);
        access(*pNode);
        InOrderTraverse(pNode->pRightNode);
    }
}

//recursely postorder
void PostOrderTraverse(PTreeNode pNode)
{
    if(pNode != NULL)
    {
        PostOrderTraverse(pNode->pLeftNode);
        PostOrderTraverse(pNode->pRightNode);
        access(*pNode);
    }
}
//////////////////////////////////////////////////////////////////////////
//非递归前序遍历二叉树
//思路：一样，要用堆栈保存左右子树，保存顺序为先右后左。
//
//////////////////////////////////////////////////////////////////////////
void NonRecursivePreOrder(PTreeNode pNode)
{
    stack<PTreeNode> s;
    
    PTreeNode p = pNode;
    while(NULL != p || !s.empty())
    {
        access(*p);
        if(NULL != p->pRightNode)
            s.push(p->pRightNode);
        if(NULL != p->pLeftNode)
            s.push(p->pLeftNode);

        if(!s.empty())
        {
            p = s.top();
            s.pop();
        }
        else
            p = NULL;
    }
    
}
//////////////////////////////////////////////////////////////////////////
// 非递归中序遍历二叉树
//思路：首先，由于是去掉了递归，必须保存以前访问过的中间节点，所以必须有堆栈。
//其次根据中序遍历的定义，是左中右，所以要找到最左边的叶子节点，并用堆栈保存根节点。
//访问完左节点后（NULL也算一个左节点），出栈并访问中间节点，最后访问右节点，并循环之。
//结束条件：堆栈为空或者指针为空，之所以加入指针为空是为了在最开始的时候不必把根节点压入堆栈。
//可以对所有节点一视同仁，简化判断。因此在中间要判断堆栈不为空才弹。
//////////////////////////////////////////////////////////////////////////
void NonRecursiveInOrder(PTreeNode pNode)
{
    stack<PTreeNode> s;

    PTreeNode p = pNode;
    while(NULL != p || !s.empty())
    {
        while(NULL != p)
        {
            s.push(p);
            p = p->pLeftNode;
        }
        
        if(!s.empty())
        {
            p = s.top();
            s.pop();
            access(*p);
            p = p->pRightNode;
        }
    }
}

//////////////////////////////////////////////////////////////////////////
//非递归后序遍历二叉树
//用一个标记标志是否是从右子树回到中间节点，这样，还是先访问左，再访问右，
//最后访问中间。
//
//
//////////////////////////////////////////////////////////////////////////
void NonRecursivePostOrder(PTreeNode pNode)
{
    stack<PTreeNode> s;

    PTreeNode p = pNode;
    while(NULL != p || !s.empty())
    {
        while(NULL != p)
        {
            s.push(p);
            p = p->pLeftNode;
        }

        if(!s.empty())
        {
            p = s.top();
            if(p->flag)
            {
                access(*p);
                s.pop();//访问完了再出栈
                p = NULL; //右子树已经访问
            }
            else
            {
                p->flag = true;
                p = p->pRightNode;  //访问右子树
            }    
        }
    }
}

//////////////////////////////////////////////////////////////////////////
//根据先序和中序遍历的结果重建二叉树 此题原自编程之美3.9
//输入：pPreOrder, pInOrder, nTreeLen
//输出：pRoot
//算法思想：先序集合不变，中序集合是变化的，每次递归做三件事：找根节点 FindRoot ，即查找先序集合中第一个
//同时又在中序集合的节点；第二步，根据根节点切分中序集合 Split ，实质上是把中序分为左右子树集合
//；第三步，递归构建左子树与右子树；
//二叉树最本质的特性就是递归，这是由它的定义决定的，所以递归是解决二叉树问题的神器。
//////////////////////////////////////////////////////////////////////////
const int maxLen = 20;
void Split(char c, char* pInOrder, char** pInOrder1, char** pInOrder2)
{
    *pInOrder1 = new char[maxLen];
    *pInOrder2= new char[maxLen];
    memset(*pInOrder1,0,sizeof(char)*maxLen);
    memset(*pInOrder2,0,sizeof(char)*maxLen);

    int j1=0;
    int j2=0;
    int i=0;
    for(; NULL != pInOrder[i]; i++)
    {
        if(c != pInOrder[i])
        {
            (*pInOrder1)[j1] = pInOrder[i];
            j1++;
        }
        else
            break;
    }
    i++;
    for(; NULL != pInOrder[i]; i++)
    {
        (*pInOrder2)[j2] = pInOrder[i];
        j2++;
    }
}

char FindRoot(char* pPreOrder, char* pInOrder)
{
    char c = NULL;
    for(int i=0; NULL != pPreOrder[i]; i++)
    {
        for(int j=0; NULL != pInOrder[j]; j++)
        {
            if(pPreOrder[i] == pInOrder[j])
            {
                c = pPreOrder[i];
                return c;
            }
        }
    }
    return c;
}

PTreeNode CreateNode(char c)
{
    PTreeNode p = new TreeNode;
    p->nodeName = c;
    p->pLeftNode = NULL;
    p->pRightNode = NULL;

    return p;
}

PTreeNode Rebuild2(char* pPreOrder, char* pInOrder)
{
    if(0 == strlen(pInOrder))
    {
        return NULL;
    }

    //找根节点
    char c = FindRoot(pPreOrder,pInOrder);
    PTreeNode p = CreateNode(c);
    char* pInOrder1 = NULL;
    char* pInOrder2 = NULL;
    //根据根节点切分中序集合
    Split(c,pInOrder,&pInOrder1,&pInOrder2);
    //重建左子树
    p->pLeftNode = Rebuild2(pPreOrder,pInOrder1);
    //重建右子树
    p->pRightNode = Rebuild2(pPreOrder, pInOrder2);
    
    delete pInOrder1;
    delete pInOrder2;
    return p;
}

void Rebuild(char* pPreOrder, char* pInOrder, int nTreeLen, PTreeNode* pRoot)
{
    *pRoot = Rebuild2(pPreOrder,pInOrder);
}
//////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////
//层次遍历二叉树
//思路：应用队列即可轻松实现，在实现上保持与其他遍历代码的一致性，主要体现在
//循环终止条件上
//
//////////////////////////////////////////////////////////////////////////
void LevelTraverse(PTreeNode root)
{
    queue<PTreeNode> q;
    PTreeNode p = root;

    while(NULL != p || !q.empty())
    {
        if(!q.empty())
        {
            p = q.front();
            q.pop();
        }
        access(*p);
        if(NULL != p->pLeftNode)
        {
            q.push(p->pLeftNode);
        }
        if(NULL != p->pRightNode)
        {
            q.push(p->pRightNode);
        }
        p = NULL; //to make the program ends after accessing the last node
    }
}


//////////////////////////////////////////////////////////////////////////
//非递归打印二叉树中某层次的节点
//
//
//////////////////////////////////////////////////////////////////////////
int PrintNodeAtLevel(PTreeNode root, int level)
{
    queue<PTreeNode> q;
    PTreeNode p = root;

    if(root == NULL || level < 0)
        return 0;

    int l = 0;
    while(NULL != p || !q.empty())
    {
        if(!q.empty())
        {
            p = q.front();
            q.pop();
        }
        if(level == p->level)
        {
            access(*p);
        }
        if(NULL != p->pLeftNode)
        {
            q.push(p->pLeftNode);
            p->pLeftNode->level = p->level+1;
        }
        if(NULL != p->pRightNode)
        {
            q.push(p->pRightNode);
            p->pRightNode->level = p->level+1;
        }
        p = NULL; //to make the program ends after accessing the last node
    }
    return 1;
}

///////////////////////////////////////////////////////////////////////////
//递归按层打印二叉树,此法把记录层次的任务交给函数本身，乃递归的妙用
//
//////////////////////////////////////////////////////////////////////////
int RecursivePrintAtLevel(PTreeNode root, int level)
{
    if(level < 0 || root == NULL)
        return 0;

    if(level == 0)
    {
        access(*root);
        return 1;
    }
    
    return RecursivePrintAtLevel(root->pLeftNode,level-1) + RecursivePrintAtLevel(root->pRightNode,level-1);
}

//////////////////////////////////////////////////////////////////////////
//递归求二叉树的深度
//
//
//////////////////////////////////////////////////////////////////////////
int RecursiveGetTreeDepth(PTreeNode root)
{
    if(NULL == root)
        return 0;
    else
    {
        int l = RecursiveGetTreeDepth(root->pLeftNode);
        int r = RecursiveGetTreeDepth(root->pRightNode);
        return (l > r ? l+1 : r+1);
    }
}

int main(void)
{
    PTreeNode p = CreateBinaryTree();


    DeleteTree(p);
    getchar();//skip enter
    getchar();//pause
    return 0;
}