二叉树非递归先序、中序、后序遍历及递归程序

typedef string DataType;

typedef struct Node
{
    DataType data;
    struct Node *lChild;
    struct Node *rChild;
}BTree;

//--------------------------------- 创建树 -----------------------------------------------------------------------
// 函数说明        ：应用一个数组elems[n]来创建一棵二叉树。elems[1]放入树根的节点数据，elems[2*i]为elems[i]的左
//                  孩子节点数据，elems[2*i+1]为elems[i]d的右孩子节点数据。elems[k] = "#"代表为空节点。
// @param elems :数据元素
// @param num    :数据元素个数
// 注意！！！    ：数据元素下表从1开始，而非数组下表0；
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void CreateBTreeByArray(BTree *&bTree, DataType elems[], int num);
 
//--------------------------------- 先根遍历递归方法 ------------------------------------------------------------
// 函数说明        ：先序遍历一个二叉树，树根节点bTree, Print为一个函数指针，由外部传入，用来打印节点值；用法如下
//                  <1> 先定义一个打印函数 Print,如下：
//                    bool Print(DataType data)
//                    {
//                        cout << " " << data << " ";
//                        return true;
//                    }
//                  <2> 按如下方式调用：
//                    PreOrder_DiGui(bTree, Print);
// @param bTree ：树根节点
// @param Print    ：打印函数指针，负责打印节点值
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void PreOrder_DiGui(BTree *bTree, bool(*Print)(DataType data));

//--------------------------------- 中序遍历递归方法 ------------------------------------------------------------
// 函数说明        ：中序遍历一个二叉树，树根节点bTree, Print为一个函数指针，由外部传入，用来打印节点值      
// @param bTree ：树根节点
// @param Print    ：打印函数指针，负责打印节点值
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void InOrder_DiGui(BTree *bTree, bool(*Print)(DataType data));

//--------------------------------- 后根遍历递归方法 ------------------------------------------------------------
// 函数说明        ：后序遍历一个二叉树，树根节点bTree, Print为一个函数指针，由外部传入，用来打印节点值      
// @param bTree ：树根节点
// @param Print    ：打印函数指针，负责打印节点值
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void PostOrder_DiGui(BTree *bTree, bool(*Print)(DataType data));

//--------------------------------- 先序遍历非递归法 ------------------------------------------------------------
// 函数说明        ：先序遍历一个二叉树，树根节点bTree, Print为一个函数指针，由外部传入，用来打印节点值      
// @param bTree ：树根节点
// @param Print    ：打印函数指针，负责打印节点值
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void PreOrder_NoDiGui(BTree *bTree, bool(*Print)(DataType data));

//--------------------------------- 中序遍历非递归法 ------------------------------------------------------------
// 函数说明        ：中序遍历一个二叉树，树根节点bTree, Print为一个函数指针，由外部传入，用来打印节点值      
// @param bTree ：树根节点
// @param Print    ：打印函数指针，负责打印节点值
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void InOrder_NoDiGui(BTree *bTree, bool(*Print)(DataType data));

//--------------------------------- 后序遍历非递归法 ------------------------------------------------------------
// 函数说明        ：后序遍历一个二叉树，树根节点bTree, Print为一个函数指针，由外部传入，用来打印节点值      
// @param bTree ：树根节点
// @param Print    ：打印函数指针，负责打印节点值
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void PostOrder_NoDiGui(BTree *bTree, bool(*Print)(DataType data));

//--------------------------------- 打印节点X的所有祖先节点 -----------------------------------------------------
// 函数说明        ：打印节点值为X的所有祖先节点      
// @param bTree ：树根节点
// @param X        ：数值X
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void PrintParentOfXNode(BTree *bTree, DataType X);

/****分割线*****分割线*****分割线*****分割线******分割线****分割线*****分割线*****分割线******分割线****分割线*—*/

// 创建二叉树
void CreateBTreeByArray(BTree *& bTree, DataType elems[], int num)
{
    BTree **tempNodeArray = new BTree*[num + 1];
    for (int i = 0; i <= num; i++)
    {
        tempNodeArray[i] = nullptr;
    }
    
    for (int i = 1; i <= num; i++)
    {
        if (elems[i] != "#")
        {
            tempNodeArray[i] = new BTree;
            tempNodeArray[i]->data = elems[i];
            tempNodeArray[i]->lChild = nullptr;
            tempNodeArray[i]->rChild = nullptr;
        }
    }

    for (int i = 1; i <= num / 2; i++)
    {
        tempNodeArray[i]->lChild = tempNodeArray[2 * i];
        if (2 * i + 1 <= num)
        {
            tempNodeArray[i]->rChild = tempNodeArray[2 * i + 1];
        }
    }
    bTree = tempNodeArray[1];
    delete[] tempNodeArray;
}

// 先序递归遍历
void PreOrder_DiGui(BTree * bTree,bool(*Print)(DataType data))
{
    if (bTree != nullptr)
    {
        Print(bTree->data);
        PreOrder_DiGui(bTree->lChild, Print);
        PreOrder_DiGui(bTree->rChild, Print);
    }
}

// 中序递归遍历
void InOrder_DiGui(BTree * bTree, bool(*Print)(DataType data))
{
    if (bTree != nullptr)
    {
        InOrder_DiGui(bTree->lChild, Print);
        Print(bTree->data);
        InOrder_DiGui(bTree->rChild, Print);
    }
}

// 后序递归遍历
void PostOrder_DiGui(BTree * bTree, bool(*Print)(DataType data))
{
    if (bTree != nullptr)
    {
        PostOrder_DiGui(bTree->lChild, Print);
        PostOrder_DiGui(bTree->rChild, Print);
        Print(bTree->data);
    }
    
}

// 先序非递归遍历
void PreOrder_NoDiGui(BTree * bTree, bool(*Print)(DataType data))
{
    BTree* curNode = bTree;

    const int maxStackNum = 100;
    BTree* stack[maxStackNum];
    int top = -1;

    stack[++top] = curNode;

    while (top > -1)
    {
        Print(stack[top]->data);
        curNode = stack[top--];
        if(curNode->rChild != nullptr)
            stack[++top] = curNode->rChild;
        if(curNode->lChild != nullptr)
            stack[++top] = curNode->lChild;
    }
}

// 中序非递归遍历
void InOrder_NoDiGui(BTree * bTree, bool(*Print)(DataType data))
{
    BTree*        curNode    = bTree;

    const int    maxStackNum = 100;
    BTree*        stack[maxStackNum];
    int            top = -1;

    while (curNode != nullptr || top > -1)
    {
        if (curNode != nullptr)
        {
            stack[++top] = curNode;
            curNode = curNode->lChild;
        }
        else
        {
            curNode = stack[top]->rChild;
            Print(stack[top--]->data);
        }
    }
}

// 后序非递归遍历
void PostOrder_NoDiGui(BTree * bTree, bool(*Print)(DataType data))
{
    BTree*        curNode    = bTree;
    BTree*        preNode = nullptr;

    const int    maxStackNum    = 100;    
    BTree*        stack[maxStackNum];
    int            top    = -1;

    do {
        while (curNode != nullptr)
        {
            stack[++top] = curNode;
            curNode = curNode->lChild;
        }
        
        Print(stack[top]->data);                // 访问节点数据
        preNode = stack[top--];        

        if (top > -1 && preNode == stack[top]->lChild)        // 若从左孩子退回，则右孩子进栈
        {
            curNode = stack[top]->rChild;
        }
        else
        {
            curNode = nullptr;
        }
    } while (top > -1);
}

// // 打印节点X的所有祖先节点
void PrintParentOfXNode(BTree *bTree, DataType X)
{
    const int maxSize = 50;
    BTree *(stack[maxSize]);
    BTree *curNode = bTree;
    BTree *tempNode = nullptr;
    int top = -1;
    int visitOfrChild[maxSize] = { 0 };

    stack[++top] = curNode;                // 根节点进栈
    curNode = curNode->lChild;

    while (top > -1)                    // 栈不空循环
    {
        while (curNode != nullptr)        // 左孩子全部进栈
        {
            stack[++top] = curNode;
            curNode = curNode->lChild;
            visitOfrChild[top] = 0;
        }

        if (stack[top]->data == X)
        {
            for (int i = 0; i < top; i++)
            {
                cout << stack[i]->data << " ";
            }
        }
        //        cout << stack[top]->data << " ";// 访问栈首节点
        top--;

        if (visitOfrChild[top] == 0)
        {
            curNode = stack[top]->rChild;
            visitOfrChild[top] = 1;
        }

    }
}