二叉树操作总结

　　对于二叉树，有前序、中序、后序三种遍历方法，由于树的定义本身就是递归定义的，故采用递归方法实现三种遍历简洁易懂。若采用非递归访问，则需要使用栈来模拟递归的实现。三种遍历的非递归算法中，前序和后序较容易，而后序相对较难。

	前序遍历	递归	非递归
树的遍历	中序遍历	递归	非递归
	后序遍历	递归	非递归
	层次遍历
计算树高
计算结点数

                      

 

 

 

 

 

1. 前序遍历【访问顺序：根结点-左孩子-右孩子】

　　a> 前序遍历递归实现

void PreOrderRecursively(BinaryTreeNode *root)
{//递归前序遍历[根，左，右]
    if(root != NULL)
    {
        cout << root->data <<" ";
        PreOrderRecursively(root->pLeft);
        PreOrderRecursively(root->pRight);
    }
}

　　b> 前序遍历非递归实现

void PreOrder(BinaryTreeNode *root)
{//非递归前序遍历：借助于栈，先将根入栈，只要栈不为空，就弹出一个结点，同时将其右孩子、左孩子入栈。
 //                   注意：右子树先入栈，以保证右子树在栈中处于左子树的下面[栈：后进先出]
    if(root == NULL)
        return;
    stack<BinaryTreeNode*> s;
    s.push(root);//根入栈

    BinaryTreeNode *temp;
    while(!s.empty())//栈不为空
    {
        temp = s.top();//访问栈顶结点
        cout << temp->data<<" ";
        s.pop();//出栈
        if(temp->pRight)
            s.push(temp->pRight);
        if(temp->pLeft)
            s.push(temp->pLeft);
    }
}

2. 中序遍历【访问顺序：左孩子-根结点-右孩子】

　　a> 中序遍历递归实现

void InOrderRecursively(BinaryTreeNode *root)
{//递归中序遍历[左，根，右]
    if(root != NULL)
    {
        InOrderRecursively(root->pLeft);
        cout << root->data << " ";
        InOrderRecursively(root->pRight);
    }
}

　　b> 中序遍历非递归实现

void InOrder(BinaryTreeNode *root)
{/*
    非递归中序遍历：
        对任一结点P,
        1）若其左孩子不为空，则将P入栈，将其左孩子置为当前P,然后对当前结点P进行相同处理；
        2) 若其左孩子为空，则取栈顶元素并出栈，访问该栈顶结点，然后将当前的P职位栈顶结点的右孩子
        3) 直到P为NULL且栈为空，则遍历结束
 */
    if(root == NULL)
        return;

    stack<BinaryTreeNode*> s;
    BinaryTreeNode *cur = root;

    while(cur != NULL || !s.empty())//P为NULL且栈为空时终止
    {
        while(cur != NULL)//直到达到最左边
        {
            s.push(cur);
            cur = cur->pLeft;
        }

        if(!s.empty())//第二种情况
        {
            cur = s.top();
            cout<<cur->data<<" ";
            s.pop();
            cur = cur->pRight;
        }
    }
}

3. 后序遍历【访问顺序：左孩子-右孩子-根结点】

　　a> 后序遍历递归实现

void PostOrderRecursively(BinaryTreeNode *root)
{//递归后序遍历[左，右，根]
    if(root != NULL)
    {
        PostOrderRecursively(root->pLeft);
        PostOrderRecursively(root->pRight);
        cout << root->data << " ";
    }
}

　　b>后序遍历非递归实现

void PostOrder(BinaryTreeNode *root)
{/*
    非递归后序遍历：[难点：保证根结点在左孩子和右孩子被访问之后才能被访问]
        根结点入栈
        对任一栈顶元素P:
        1)若P不存在左孩子和右孩子，直接访问它；或P存在左孩子或右孩子，但其左孩子或右孩子已被访问过，
          同样直接访问它。然后将P出栈，pre置为P
        2)若并非1)中的两种情况，则将P的右孩子和左孩子依次入栈，以保证每次取栈顶元素时，左孩子在右孩子
          之前被访问，左孩子和右孩子都在根结点之前被访问        
 */
    if(root == NULL)
        return;
    
    stack<BinaryTreeNode*> s;
    BinaryTreeNode *cur;
    BinaryTreeNode *pre = NULL;//指示上次被访问的结点
    s.push(root);

    while(!s.empty())//栈不为空时循环
    {
        cur = s.top();//取栈顶元素

        //当前结点无孩子结点或孩子节点都已被访问
        if((cur->pLeft == NULL && cur->pRight == NULL) || 
            (pre!=NULL && (pre==cur->pLeft || pre==cur->pRight)))
        {
            cout << cur->data<<" ";//访问该栈顶元素
            s.pop();//出栈
            pre = cur;//更新pre
        }
        else
        {
            if(cur->pRight != NULL)//右孩子入栈
                s.push(cur->pRight);
            if(cur->pLeft != NULL)//左孩子入栈
                s.push(cur->pLeft);
        }
    }
}

4.层次遍历

void LevelOrder(BinaryTreeNode *root)
{//层次遍历：只有非递归的方法
 //借助队列来实现：根结点入队，只要队列不为空，访问队首元素并出队，将其左孩子和右孩子依次入队
    if(root == NULL)
        return;
    queue<BinaryTreeNode *> q;
    q.push(root);
    BinaryTreeNode *cur;
    while(!q.empty())
    {
        cur = q.front();//队首元素
        cout << cur->data << " ";
        q.pop();//出队
        if(cur->pLeft != NULL)
            q.push(cur->pLeft);
        if(cur->pRight != NULL)
            q.push(cur->pRight);
    }
}

5.计算树高和结点数

int TreeHeight(BinaryTreeNode *root)//计算树高
{//计算树高
    if(root == NULL)//空树
        return 0;
    int heightLeft = TreeHeight(root->pLeft);//左子树高度
    int heightRight = TreeHeight(root->pRight);//右子树高度
    if(heightLeft > heightRight)
        return ++heightLeft;
    else
        return ++heightRight;
}

int CountNode(BinaryTreeNode *root)
{//计算树的结点数
    if(root == NULL)
        return 0;
    return 1+CountNode(root->pLeft)+CountNode(root->pRight);
}

 

【 完整代码】

#include "stdafx.h"
#include <iostream>
#include <stack>
#include <queue>
using namespace std;

struct BinaryTreeNode
{
    int data;
    BinaryTreeNode *pLeft;//左子树
    BinaryTreeNode *pRight;//右子树

    BinaryTreeNode(int a):data(a),pLeft(NULL),pRight(NULL) {}
};

void CreateBinaryTree(BinaryTreeNode **root)//二级指针作为函数参数
{//按先序遍历创建二叉树:操作不是很容易懂!!!
    char ch;//要插入的数据
    //cout << "input root data:";
    cin >> ch;
    if(ch == '#')//表示为空
        *root = NULL;
    else
    {
        *root = new BinaryTreeNode(ch);
        cout << "input left child:";//此时不接受输入cin!!!
        CreateBinaryTree(&((*root)->pLeft));
        cout << "input right child:";
        CreateBinaryTree(&((*root)->pRight));
    }
}


void ConnectTreeNodes(BinaryTreeNode *pRoot,BinaryTreeNode *pLeft,BinaryTreeNode *pRight)
{
    if(pRoot != NULL)
    {
        //if(pLeft)//不是pRoot->pLeft
            pRoot->pLeft = pLeft;
        //if(pRight)
            pRoot->pRight = pRight;
    }
}

void PreOrderRecursively(BinaryTreeNode *root)
{//递归前序遍历[根，左，右]
    if(root != NULL)
    {
        cout << root->data <<" ";
        PreOrderRecursively(root->pLeft);
        PreOrderRecursively(root->pRight);
    }
}

void PreOrder(BinaryTreeNode *root)
{//非递归前序遍历：借助于栈，先将根入栈，只要栈不为空，就弹出一个结点，同时将其右孩子、左孩子入栈。
 //                   注意：右子树先入栈，以保证右子树在栈中处于左子树的下面[栈：后进先出]
    if(root == NULL)
        return;
    stack<BinaryTreeNode*> s;
    s.push(root);//根入栈

    BinaryTreeNode *temp;
    while(!s.empty())//栈不为空
    {
        temp = s.top();//访问栈顶结点
        cout << temp->data<<" ";
        s.pop();//出栈
        if(temp->pRight)
            s.push(temp->pRight);
        if(temp->pLeft)
            s.push(temp->pLeft);
    }
}


void InOrderRecursively(BinaryTreeNode *root)
{//递归中序遍历[左，根，右]
    if(root != NULL)
    {
        InOrderRecursively(root->pLeft);
        cout << root->data << " ";
        InOrderRecursively(root->pRight);
    }
}

void InOrder(BinaryTreeNode *root)
{/*
    非递归中序遍历：
        对任一结点P,
        1）若其左孩子不为空，则将P入栈，将其左孩子置为当前P,然后对当前结点P进行相同处理；
        2) 若其左孩子为空，则取栈顶元素并出栈，访问该栈顶结点，然后将当前的P职位栈顶结点的右孩子
        3) 直到P为NULL且栈为空，则遍历结束
 */
    if(root == NULL)
        return;

    stack<BinaryTreeNode*> s;
    BinaryTreeNode *cur = root;

    while(cur != NULL || !s.empty())//P为NULL且栈为空时终止
    {
        while(cur != NULL)//直到达到最左边
        {
            s.push(cur);
            cur = cur->pLeft;
        }

        if(!s.empty())//第二种情况
        {
            cur = s.top();
            cout<<cur->data<<" ";
            s.pop();
            cur = cur->pRight;
        }
    }
}

void PostOrderRecursively(BinaryTreeNode *root)
{//递归后序遍历[左，右，根]
    if(root != NULL)
    {
        PostOrderRecursively(root->pLeft);
        PostOrderRecursively(root->pRight);
        cout << root->data << " ";
    }
}

void PostOrder(BinaryTreeNode *root)
{/*
    非递归后序遍历：[难点：保证根结点在左孩子和右孩子被访问之后才能被访问]
        根结点入栈
        对任一栈顶元素P:
        1)若P不存在左孩子和右孩子，直接访问它；或P存在左孩子或右孩子，但其左孩子或右孩子已被访问过，
          同样直接访问它。然后将P出栈，pre置为P
        2)若并非1)中的两种情况，则将P的右孩子和左孩子依次入栈，以保证每次取栈顶元素时，左孩子在右孩子
          之前被访问，左孩子和右孩子都在根结点之前被访问        
 */
    if(root == NULL)
        return;
    
    stack<BinaryTreeNode*> s;
    BinaryTreeNode *cur;
    BinaryTreeNode *pre = NULL;//指示上次被访问的结点
    s.push(root);

    while(!s.empty())//栈不为空时循环
    {
        cur = s.top();//取栈顶元素

        //当前结点无孩子结点或孩子节点都已被访问
        if((cur->pLeft == NULL && cur->pRight == NULL) || 
            (pre!=NULL && (pre==cur->pLeft || pre==cur->pRight)))
        {
            cout << cur->data<<" ";//访问该栈顶元素
            s.pop();//出栈
            pre = cur;//更新pre
        }
        else
        {
            if(cur->pRight != NULL)//右孩子入栈
                s.push(cur->pRight);
            if(cur->pLeft != NULL)//左孩子入栈
                s.push(cur->pLeft);
        }
    }
}

void LevelOrder(BinaryTreeNode *root)
{//层次遍历：只有非递归的方法
 //借助队列来实现：根结点入队，只要队列不为空，访问队首元素并出队，将其左孩子和右孩子依次入队
    if(root == NULL)
        return;
    queue<BinaryTreeNode *> q;
    q.push(root);
    BinaryTreeNode *cur;
    while(!q.empty())
    {
        cur = q.front();//队首元素
        cout << cur->data << " ";
        q.pop();//出队
        if(cur->pLeft != NULL)
            q.push(cur->pLeft);
        if(cur->pRight != NULL)
            q.push(cur->pRight);
    }
}

int TreeHeight(BinaryTreeNode *root)//计算树高
{//计算树高
    if(root == NULL)//空树
        return 0;
    int heightLeft = TreeHeight(root->pLeft);//左子树高度
    int heightRight = TreeHeight(root->pRight);//右子树高度
    if(heightLeft > heightRight)
        return ++heightLeft;
    else
        return ++heightRight;
}

int CountNode(BinaryTreeNode *root)
{//计算树的结点数
    if(root == NULL)
        return 0;
    return 1+CountNode(root->pLeft)+CountNode(root->pRight);
}

BinaryTreeNode* TestCreate()
{//建树的测试函数
    /*
        建树
                1
              /   
            2       3
           /        
          4   5       6       
         /
        7
    */
    BinaryTreeNode* pNodeA1 = new BinaryTreeNode(1);
    BinaryTreeNode* pNodeA2 = new BinaryTreeNode(2);
    BinaryTreeNode* pNodeA3 = new BinaryTreeNode(3);
    BinaryTreeNode* pNodeA4 = new BinaryTreeNode(4);
    BinaryTreeNode* pNodeA5 = new BinaryTreeNode(5);
    BinaryTreeNode* pNodeA6 = new BinaryTreeNode(6);
    BinaryTreeNode* pNodeA7 = new BinaryTreeNode(7);

    ConnectTreeNodes(pNodeA1, pNodeA2, pNodeA3);
    ConnectTreeNodes(pNodeA2, pNodeA4, pNodeA5);
    ConnectTreeNodes(pNodeA3, NULL, pNodeA6);
    ConnectTreeNodes(pNodeA4, pNodeA7,NULL);

    cout << endl << "PreOrder:";
    PreOrder(pNodeA1);//1 2 4 7 5 3 6
    cout <<  endl << "InOrder:";
    InOrder(pNodeA1);//7 4 2 5 1 3 6
    cout << endl <<  "PostOrder:";
    PostOrder(pNodeA1);//7 4 5 2 6 3 1
    cout <<  endl << "LevelOrder:";
    LevelOrder(pNodeA1);//1 2 3 4 5 6 7

    return pNodeA1;//因为没有delete，故返回后仍可访问
}
int main()
{
    BinaryTreeNode *root = TestCreate();//定义根结点
    
    cout <<  endl << "LevelOrder:";
    LevelOrder(root);//1 2 3 4 5 6 7
    
}

 

 

参考：http://blog.csdn.net/xiajun07061225/article/details/12760627

　　   http://blog.csdn.net/hackbuteer1/article/details/6583988