非递归遍历二叉树C语言

非递归遍历二叉树

非递归遍历二叉树通过队列和栈实现。

层序遍历二叉树

/*层序遍历二叉树*/
void LevelOrderTraverse(BinaryTree T)
{
    BinaryTree p = T;
    LinkQueue Q;
    LinkQueue_Init(&Q);
    LinkQueue_Enter(&Q, p);
    while (LinkQueue_Empty(Q) == false)
    {
        p = LinkQueue_Delete(&Q);  //根结点出队
        printf("%c ", p.data);     //访问根结点
        if (p.LChild != NULL)      //左子树不空，入队
        {
            LinkQueue_Enter(&Q, *p.LChild);
        }
        if (p.RChild != NULL)      //右子树不空，入队
        {
            LinkQueue_Enter(&Q, *p.RChild);
        }
    }
    printf("\n");
}

先序遍历二叉树

/*先序遍历二叉树，根——左——右*/
void PreOrderTraverse(BinaryTree T)
{
    BinaryTree* p = &T;
    BinaryTree* q = &T;
    LinkStack S;
    LinkStack_Init(&S);
    while (p != NULL || LinkStack_Empty(S) == false)
    {
        if (p != NULL)
        {
            printf("%c ", p->data);    //访问根结点
            LinkStack_Push(&S, *p);
            p = p->LChild;             //左孩子非空入栈
        }
        else
        {
            *q = LinkStack_Pop(&S);   //根结点出栈
            p = q->RChild;            //右孩子非空入栈  

        }
    }
    printf("\n");
}

中序遍历二叉树

/*中序遍历二叉树，左——根——右*/
void InOrderTraverse(BinaryTree T)
{
    BinaryTree* p = &T;
    BinaryTree* q = &T;
    LinkStack S;
    LinkStack_Init(&S);
    while (p != NULL || LinkStack_Empty(S) == false)
    {
        if (p != NULL)
        {
            LinkStack_Push(&S, *p);
            p = p->LChild;             //左孩子非空入栈
        }
        else
        {
            *q = LinkStack_Pop(&S);    //根结点出栈
            printf("%c ", q->data);    //访问根结点
            p = q->RChild;             //右孩子非空入栈
        }
    }
    printf("\n");
}

后序遍历二叉树

/*后序遍历二叉树，左——右——根*/
void PostOrderTraverse(BinaryTree T)
{
    BinaryTree* p = &T;
    BinaryTree* q = &T;
    LinkStack S,temp;
    LinkStack_Init(&S);
    LinkStack_Init(&temp);
    while (p != NULL || LinkStack_Empty(S) == false)
    {
        if (p != NULL)
        {
//          printf("%c ", p->data);      //访问根结点
//将根——右——左顺序访问的结点存入栈中
            LinkStack_Push(&temp, *p); 
            LinkStack_Push(&S, *p);
            p = p->RChild;              //右孩子非空入栈
        }
        else
        {
            *q = LinkStack_Pop(&S);   //根结点出栈
            p = q->LChild;            //左孩子非空入栈
        }
    }
//遍历栈得到左——右——根顺序的结点
    LinkStack_Traverse(temp);
//销毁暂存栈
    LinkStack_Clear(&temp);
}

测试程序：

int main()
{
    BinaryTree T = { 'A',NULL,NULL };
    BinaryTreeNode NewNode1 = { 'B',NULL,NULL };
    BinaryTreeNode NewNode2 = { 'C',NULL,NULL };
    BinaryTreeNode NewNode3 = { 'D',NULL,NULL };
    BinaryTreeNode NewNode4 = { 'E',NULL,NULL };
    BinaryTreeNode NewNode5 = { 'F',NULL,NULL };
    BinaryTreeNode NewNode6 = { 'G',NULL,NULL };

    T.LChild = &NewNode1;
    T.RChild = &NewNode2;
    NewNode1.LChild = &NewNode3;
    NewNode1.RChild = &NewNode4;
    NewNode2.LChild = &NewNode5;
    NewNode2.RChild = &NewNode6;

    printf("层序遍历："); 
    LevelOrderTraverse(T);
    printf("前序遍历："); 
    PreOrderTraverse(T);
    printf("中序遍历：");
    InOrderTraverse(T);
    printf("后序遍历："); 
    PostOrderTraverse(T);
    //LinkStack_Test();
    //LinkQueue_Test();
    return 0;
}

测试结果：