【数据结构】二叉树遍历（递归+非递归）

二叉树定义：

typedef struct BiTreeNode {
    char data;  
    struct BiTreeNode *left, *right;
} BiTreeNode, *BiTree;

二叉树的创建：

int CreatBiTree(Bitree &T) {
    char data;
    // 按先序次序输入二叉树中节点的值（一个字符），"#"表示空树
    scanf("%c",data);
    if (data == '#') {
        T = NULL;
    } else {
        T = (BiTree)malloc(sizeof(BiTreeNode);
        // 生成根节点
        T -> data = data;
        // 构造左子树
        CreateBiTree(T -> left);
        // 构造右子树
        CreateBiTree(T -> right);
    }
    return 0;
}

##【递归】

// 打印
void printTree(BiTree T) {
    if (T -> data != '#') {
        printf("%c",T -> data);
    }
}

// 先序遍历
void PreOrder(BiTree T) {
    if (T != NULL) {
        printTree(T);
        PreOrder(T -> left);
        PreOrder(T -> right);
    }
}

// 中序遍历
void InOrder(BiTree T) {
    if (T != NULL) {
        InOrder(T -> left);
        printTree(T);
        InOrder(T -> right);
    }
}

// 后序遍历
void PostOrder(BiTree T) {
    if (T != NULL) {
        PostOrder(T -> left);
        PostOrder(T -> right);
        printTree(T);
    }
}

【非递归】

// 先序遍历
void PreOrder2(BiTree T) {
    stack<BiTree> stack;
    BiTree p = T; // p是遍历指针
    while (p || !stack.empty()) {
        if (p != NULL) {
            stack.push(p); // 入栈
            printf("%c",p -> data);
            p = p -> left; 
        } else {
            p = stack.top();
            stack.pop();
            p = p -> right;
        }
    }
}

// 中序遍历
void InOrder2(BiTree T) {
    stack<BiTree> stack;
    BiTree p = T; // p是遍历指针
    while (p || !stack.empty()) {
        if (p != NULL) {
            stack.push(p); // 入栈
            p = p -> left; 
        } else {
            p = stack.top();
            printf("%c",p -> data);
            stack.pop();
            p = p -> right;
        }
    }
}

// 后序遍历
typedef struct BiTreeNodePost {
    char tag;
    BiTree biTree;
}BiTreeNodePost, *BiTreePost;

void PostOrder2(BiTree T) {
    stack<BiTree> stack;
    BiTree p = T; // p是遍历指针
    BiTreePost BT;
    while (p || !stack.empty()) {
        // 遍历左子树
        while (p != NULL) {
            BT = (BiTreePost)malloc(sizeof(BiTreeNodePost));
            BT -> biTree = p;
            // 访问过左子树
            BT -> tag = 'L';
            stack.push(BT);
            p = p -> child;
        }
        // 左右子树访问完毕访问根节点
        while (!stack.empty() && (stack.top()) - > tag == 'R') {
            BT = stack.top();
            stack.pop();
            BT -> biTree;
            printf("%c",BT -> biTree -> data);
        }
        // 遍历右子树
        if (!stack.empty()) {
            BT = stack.top();
            // 访问过右子树
            BT -> tag = 'R';
            p = BT -> biTree;
            p = p -> right;
        }
    }
}

// 层次遍历
void LevelOrder(BiTree T) {
    BiTree p = T;
    queue<BiTree> queue;
    queue.push(p);
    while(!queue.empty()) {
        // 对头元素出队
        p = queue.front();  
        // 访问p指向的节点
        printf("%c",p -> data);
        queue.pop();
        if (p -> left != NULL) {
            queue.push(p -> left);
        }
        if (p -> right != NULL) {
            queue.push(p -> right);
        }
    }
}