数据结构与算法随笔之------二叉树的遍历（一文搞懂二叉树的四种遍历）

二叉树的遍历

• 二叉树的遍历（traversing binary tree）是指从根结点出发，按照某种次序依次访问二叉树中所有的结点，使得每个结点被访问依次且仅被访问一次。
• 遍历分为四种，前序遍历，中序遍历，后序遍历及层序遍历

前序	中	左	右
中序	左	中	右
后序	左	右	中

1.前序遍历

若树为空，则空操作返回。否则，先访问根节点，然后前序遍历左子树，再前序遍历右子树。（W）型 （中 左 右）


 先序遍历的递归实现代码：

void PreorderTraversal( BinTree BT )
{
    if( BT ) {
        printf("%d ", BT->Data );
        PreorderTraversal( BT->Left );
        PreorderTraversal( BT->Right );
    }
}

前序遍历的非递归实现：

BinTree PreorderTraversal( BinTree BT )
{
	stack<BinTree> s;
    BinTree T = BT;
    while(T||!s.empty())
    {
        while(T)
        {
        	cout<<T->data<<" ";
            s.push(T);
            T = T->left;
        }
        if(!s.empty())
        {
            T = pop(s);
            T = T->right;
        }
    }    
}

2.中序遍历

若树为空，则空操作返回。否则，从根节点开始（注意并不是先访问根节点），中序遍历根节点的左子树，然后是访问根节点，最后中序遍历根节点的右子树。（M）型，（左 中 右）


 中序遍历的递归实现代码： 

void InorderTraversal( BinTree BT )
{
    if( BT ) {
        InorderTraversal( BT->Left );
        /* 此处假设对BT结点的访问就是打印数据 */
        printf("%d ", BT->Data); /* 假设数据为整型 */
        InorderTraversal( BT->Right );
    }
}

中序遍历的非递归实现：

 

void InorderTraversal( BinTree BT )    //非递归中序遍历
{
    stack<BinTree> s;
    BinTree T = BT;
    while(T||!s.empty())
    {
        while(T)
        {
            s.push(T);
            T = T->left;
        }
        if(!s.empty())
        {
            T = pop(s);
            cout<<T->data<<" ";
            T = T->right;
        }
    }    
}

• 3.后续遍历

若树为空，则空操作返回。否则，从左到右先叶子后节点的方式遍历访问左右子树，最后访问根节点。（左右中）逆时针型 （左 右 中）


后序遍历的递归实现代码： 

void PostorderTraversal( BinTree BT )
{
    if( BT ) {
        PostorderTraversal( BT->Left );
        PostorderTraversal( BT->Right );
        printf("%d ", BT->Data);
    }
}

后序遍历的非递归实现代码： 

后序遍历的非递归实现是三种遍历方式中最难的一种。因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根结点，这就为流程的控制带来了难题。下面介绍两种思路。

      第一种思路：对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问， 因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就 保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是 否是第一次出现在栈顶。

void postOrder2(BinTree *root)    //非递归后序遍历
{
    stack<BTNode*> s;
    BinTree *p=root;
    BTNode *temp;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)              //沿左子树一直往下搜索，直至出现没有左子树的结点 
        {
            BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
            btn->btnode=p;
            btn->isFirst=true;
            s.push(btn);
            p=p->lchild;
        }
        if(!s.empty())
        {
            temp=s.top();
            s.pop();
            if(temp->isFirst==true)     //表示是第一次出现在栈顶 
             {
                temp->isFirst=false;
                s.push(temp);
                p=temp->btnode->rchild;    
            }
            else                        //第二次出现在栈顶 
             {
                cout<<temp->btnode->data<<" ";
                p=NULL;
            }
        }
    }    
}

 第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存 在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了 每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

void postOrder3(BinTree *root)     //非递归后序遍历
{
    stack<BinTree*> s;
    BinTree *cur;                      //当前结点 
    BinTree *pre=NULL;                 //前一次访问的结点 
    s.push(root);
    while(!s.empty())
    {
        cur=s.top();
        if((cur->lchild==NULL&&cur->rchild==NULL)||
           (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
        {
            cout<<cur->data<<" ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
              s.pop();
            pre=cur; 
        }
        else
        {
            if(cur->rchild!=NULL)
                s.push(cur->rchild);
            if(cur->lchild!=NULL)    
                s.push(cur->lchild);
        }
    }    
}

4.层序遍历

若树为空，则空操作返回。否则，从树的第一层，也就是根节点开始访问，从上到下逐层遍历，在同一层中，按从左到右的顺序结点逐个访问。

层序遍历队列实现： 

void LevelorderTraversal ( BinTree BT )
{ 
    Queue Q; 
    BinTree T;
    if ( !BT ) return; /* 若是空树则直接返回 */
    Q = CreatQueue(); /* 创建空队列Q */
    AddQ( Q, BT );
    while ( !IsEmpty(Q) ) {
        T = DeleteQ( Q );
        printf("%d ", T->Data); /* 访问取出队列的结点 */
        if ( T->Left )   AddQ( Q, T->Left );
        if ( T->Right )  AddQ( Q, T->Right );
    }
}

 此外也可以用数组模拟实现（有些区别，仔细看看）

这两个下标shuzu和index有点不好理解，我解释一下

两个都是队列数组的下标，但功能不同

index其实就是放进队列里的下标，放一次它就++一次，这个下标其实也就是层序遍历的次序

最难理解的就是shuzu这个下标，其实他是一个控制输出的数组，毕竟层序遍历是一层一下子就压进来了，但是输出顺序要从左到右输出

void LevelorderTraversal( BinTree BT )//层序遍历 
{
	if(BT == NULL)
	    return;
	BinTree p[101];
	int shuzu = 0,index = 0;//两个都是队列数组的下标，但功能不同
//前者有点类似控制输出的下标，总是指向队头。后者则是为了储存层序遍历的次序
	p[index++] = BT;//头结点入队
	while(shuzu < index)
	{
		BinTree q = p[shuzu++];//q其实就是队列数组中的第一个元素
		printf(" %c",q->Data);//逐层输出结点 ，然后将他的两个孩子放入下标数组中 
		if(q->Left != NULL)
		{
			p[index++] = q->Left;
		}
		if(q->Right != NULL)
		{
			p[index++] = q->Right;
		}
	}
	
} 

5.小结：二叉树前三种顺序的遍历过程有如下特点

6.来道例题（树的同构问题）

一定理解如何判断根节点！