二叉树的前序、中序、后序、层序遍历

数据表示：

//二叉链表存储 
struct BTNode
{
    struct BTNode *LChild;    // 指向左孩子指针
    ELEMENTTYPE    data;      // 结点数据
    struct BTNode *RChild;    // 指向右孩子指针
};

前序遍历：

// 递归实现
void PreorderTraversal(BTNode *BT)
{
    if(BT!=NULL) {
        Print(BT->data);                                // 访问根结点
        PreorderTraversal(BT->LChild);                  // 前序遍历左子树
        PreorderTraversal(BT->RChild);                  // 前序遍历右子树
    }
}

// 非递归实现
void PreorderTraversal(BTNode *BT)
{
    InitStack(stack, treeDeepth);                       // 初始化元素为结点指针类型的栈stack，用以保存结点的指针
    BTNode *current = BT;                               // current指向但前要访问的结点，初始时指向根结点
    while(current != NULL || !EmptyStack(stack)) {      /* current为空结点且栈空，遍历结束 */
        if(current != NULL) {                           /* 若current不是空结点 */
            Print(current->data);                       // 访问current指向的结点
            Push(stack, current);                       // 当前结点指针current压栈
            current = current->LChild;                  // 使current的左孩子成为当前结点
        } else {                                        /* 若current指向的为空结点 */
            current = Pop(stack);                       // 弹出栈顶的结点指针赋给current
            current = current->RChild;                  // 使current的右孩子成为当前结点
        }
    }
}

中序遍历：

// 递归实现
void InorderTraversal(BTNode *BT)
{
    if(BT!=NULL) {
        InorderTraversal(BT->LChild);                   // 中序遍历左子树
        Print(BT->data);                                // 访问根结点
        InorderTraversal(BT->RChild);                   // 中序遍历右子树
    }
}

// 非递归实现
void InorderTraversal(BTNode *BT)
{
    InitStack(stack, treeDeepth);                       // 初始化元素为结点指针类型的栈stack，用以保存结点的指针
    BTNode *current = BT;                               // current指向但前要访问的结点，初始时指向根结点
    while(current != NULL || !EmptyStack(stack)) {      /* current为空结点且栈空，遍历结束 */
        if(current != NULL) {                           /* 若current不是空结点 */
            Push(stack, current);                       // 当前结点指针current压栈
            current = current->LChild;                  // 使current的左孩子成为当前结点
        } else {                                        /* 若current指向的为空结点 */
            current = Pop(stack);                       // 弹出栈顶的结点指针赋给current
            Print(current->data);                       // 访问current指向的结点
            current = current->RChild;                  // 使current的右孩子成为当前结点
        }
    }
}

后序遍历：

// 递归实现
void PostorderTraversal(BTNode *BT)
{
    if(BT!=NULL) {
        PostorderTraversal(BT->LChild);                 // 后序遍历左子树
        PostorderTraversal(BT->RChild);                 // 后序遍历右子树
        Print(BT->data);                                // 访问根结点
    }
}

// 非递归实现
void PostorderTraversal(BTNode *BT)
{
    InitStack(stack, treeDeepth);                       // 初始化元素为结点指针类型的栈stack，用以保存结点的指针
    BTNode *current = BT;                               // current指向但前要访问的结点，初始时指向根结点
    Push(stack, current);                               // 当前结点指针current压栈
    while(current->LChild != NULL) {                    /* 从当前结点出发，逐步找到二叉树左边结点并依次进栈 */
        current = current->LChild;
        Push(stack, current);
    }
    while(!EmptyStack(stack)) {                         /* 一直进行到栈空为止，整棵二叉树遍历完成 */
        current = Pop(stack);                           // 栈顶结点退栈作为当前结点
        if(current < 0) {                       /* 若当前结点指针标志为“负”，表示该结点的右子树已遍历完，应该访问该结点 */ 
            current = -current;                 /******* 对指针加正负号，OK，学习了，竟然这样子来标识 *******/
            Print(current->data);
        } else {                                /* 若当前结点标志为“正”，表示该结点的左子树已遍历完，应该遍历其右子树 */
            Push(stack, -current);                      // 对当前结点指针加左子树已遍历标志并入栈
            if(current->RChild != NULL) {               // 若当前结点有右子树，以右孩子作为当前结点，从它出发做后序遍历
                current = current->RChild;
                Push(stack, current);
                while(current->LChild != NULL) {
                    current = current->LChild;
                    Push(stack, current);
                }
            }
        }
    }
}

/*
 * 非递归实现  双栈
 * 思路：
 *  按“左-右-根”顺序遍历二叉树的顺序与按“根-右-左”顺序遍历二叉树的顺序正好相反
 *  所以，将按“根-右-左”顺序遍历二叉树的结点依次压入postStack栈中，遍历完后再
 *  输出postStack栈中所有的元素结点所对应的值即是按“左-右-根”顺序遍历二叉树的顺序
 */
void postorderTraversal(struct BTreeNode *root)
{
    initStack(tempStack, STACKSIZE);           // 初始化元素为结点类型指针的栈tempStack，用以保存刚访问过的结点，利于回溯
    initStack(postStack, BTREESIZE);           // 初始化元素为结点类型指针的栈postStack，用以保存按“根-右-左”顺序依次访问的结点

    struct BTreeNode *currentNode = root;                   // currentNode指向当前要访问的结点，初始时指向根结点
    while(currentNode != NULL || !isEmpty(tempStack)) {     /* 当currentNode为空结点其tempStack栈空，遍历结束 */
        if(currentNode != NULL) {                           // 若currentNode指向的不是空结点
            push(postStack, currentNode);                   // currentNode结点压入postStack栈中
            push(tempStack, currentNode);                   // currentNode结点压入tempStack栈中
            currentNode = currentNode->rightChild;          // 使currentNode指向当前结点的右孩子结点
        } else {                                            // 若currentNode不为空结点    
            currentNode = pop(tempStack);                   // 弹出tempStack栈顶结点指针并赋给currentNode指针
            currentNode = currentNode->LChild;              // 是使currentNode指向当前结点的左孩子结点
        }
    }
    outStack(postStack);
}

层序遍历：

/*
 * 层序遍历二叉树
 */
void levelOrderTraversal(struct BTreeNode *root)
{
    initQueue(queue, QUEUESIZE);                        // 初始化元素为二叉树结点指针类型的队列
    if(root != NULL)                                    // 若二叉树不为空，根结点指针入队
        enQueue(queue, root);

    struct BTreeNode currentNode = NULL;
    while(!isEmpty(queue)) {                            /* 直到队列为空，遍历结束 */
        currentNode = outQueue(queue);                  // 队头元素出列
        print(currentNode->data);                       // 访问当前结点信息
        if(currentNode->LChild != NULL)              　　/* 若当前结点有左孩子，则将其入队 */
            enQueue(queue, currentNode->LChild);
        if(currentNode->rightChild != NULL)             /* 若当前结点有右孩子，则将其入队 */
            enQueue(queue, currentNode->rightChild);
    }
}

二叉树遍历方法的简单应用：

/*
 * 前序遍历应用：输出二叉树   递归实现
 */
void outBTree(struct BTreeNode *root)
{
    if(root != NULL) {                                                  // 若二叉树为空
        print(root->data);                                              // 输出根结点值
        if(root->LChild != NULL || root->rightChild != NULL) {       　　// 有左子树或右子树
            print("(");                         　　　　　　　　　　　　　　 // 输出左括号
            outBT(root->LChild);             　　　　　　　　　　　　　　　　 // 输出左子树
            print(",");                         　　　　　　　　　　　　　　 // 输出左右子树的分隔符
            if(root->rightChild != NULL)        　　　　　　　　　　　　　　 // 若有右子树
                outBTree(root->rightChild);     　　　　　　　　　　　　　　 // 输出右子树            
            print(")");                         　　　　　　　　　　　　　　 // 输出右括号
        }
    }
}

/*
 * 前序遍历应用：查找二叉树中是否存在指定值   递归实现
 */
bool findBTree(struct BTreeNode *root, ElementType item)
{
    if(root == NULL) {                                          // 二叉树为空，则返回false
        return false;
    } else {
        if(root->data == item) {                                // 若根结点为所找结点，返回true
            return true;
        } else {
            if(findBTree(root->LChild, item) == true) {      　　// 递归查找当前结点的左子树，若找到，返回true
                return true;
            }
            if(findBTree(root->rightChild, item) == true) {     // 递归查找当前结点的右子树，若找到，返回false
                return true;
            }
            return false;                                       // 若左右子树都未找到，返回false
        }
    }
}

/*
 * 后序遍历应用：计算二叉树的深度     递归实现
 */
int getBTreeDeepth(struct BTreeNode *root)
{   
    if(root == NULL) {                                                      // 二叉树为空，返回深度为0
        return 0;
    } else {
        int deepth_1 = getBTreeDeepth(root->LChild);                     　　// 递归求左子树的深度
        int deepth_2 = getBTreeDeepth(root->RChild);                    　　 // 递归求右子树的深度
        return (deepth_1 > deepth_2) ? (deepth_1 + 1) : (deepth_2 + 1);     // 求出树的深度并返回
    }
}

/*
 * 后序遍历应用：清空二叉树   递归实现
 */
void clearBTree(struct BTreeNode *root)
{
    /* 若二叉树为空树，则结束递归 */
    if(root != NULL) {
        clearBTree(root->LChild);    　　　　// 递归删除根结点的左子树
        clearBTree(root->rightChild);   　　// 递归删除根结点的右子树
        delete root;     　　　　　　　　　　　 // 释放根结点
        root = NULL;    　　　　　　　　　　　　// 将根结点指针置空
    }
}

OK哒！