根据先序序列和中序序列，建出二叉树，并求出后序序列

根据先序序列和中序序列，建出二叉树，并求出后序序列

题干

• 前序遍历: GDAFEMHZ
• 中序遍历: ADEFGHMZ
• 构建对应二叉树，并输出后序序列

手动操作

step 1.

GDAFEMHZ

ADEFGHMZ

step 2.

G(DAFE)(MHZ)

(ADEF)G(HMZ)

step 3.

G(D(A)(FE)(M(H)(Z))

((A)D(EF))G((H)M(Z))

step 4.

G(D(A)(F(E))(M(H)(Z))

((A)D((E)F))G((H)M(Z))

done.

G(D(A)(F(E))(M(H)(Z))

((A)D((E)F))G((H)M(Z))

图形表示(没错图是网上的诶嘿 ;p 侵删哟)

答案

Post order sequence: AEFDHZMG

代码实现

用string及new等会更方便，然而对象看不懂，我就写老一点的?

#include <iostream>
#include <cstring>
#include <cstdlib>

#define SIZE 55
using namespace std;

typedef char ElemType;
typedef class BinaryNode {
public:
    ElemType value;
    BinaryNode *lChild, *rChild;
} BinaryNode, *BinaryTree;

void InitBinaryTree(BinaryTree &T, char *preOrder, char *inOrder) {
    int lenInOrder = strlen(inOrder)/*strlen(char* str), 求字符串str的有效长度*/,
            flag = 0;
    if (!strlen(preOrder) && !strlen(inOrder))
        return;
    T = (BinaryNode *) malloc(sizeof(BinaryNode));
    for (int i = 0; i < lenInOrder; i++)
        if (inOrder[i] == preOrder[0])
            flag = i;
    ElemType leftInOrder[SIZE], rightInOrder[SIZE],
            leftPreOrder[SIZE], rightPreOrder[SIZE];
    /
    //生成左子树的先序序列和中序序列
    for (int j = 0; j < flag; j++) {
        leftInOrder[j] = inOrder[j];
        leftPreOrder[j] = preOrder[j + 1];
    }
    leftInOrder[flag] = '\0';
    leftPreOrder[flag] = '\0';
    /
    //生成右子树的先序序列和中序序列
    for (int j = flag + 1; j < lenInOrder; j++) {
        rightInOrder[j - flag - 1] = inOrder[j];
        rightPreOrder[j - flag - 1] = preOrder[j];
    }
    rightInOrder[lenInOrder - flag - 1] = '\0';
    rightPreOrder[lenInOrder - flag - 1] = '\0';
    /
    //相应处理(此处为赋值与输出步骤)
    T->value = preOrder[0];
    cout << "root->" << preOrder[0] << ' ' << leftPreOrder << ' ' << rightPreOrder << ' ' << "pre" << endl;
    cout << leftInOrder << ' ' << "root->" << inOrder[flag] << ' ' << rightInOrder << ' ' << "in" << endl << endl;
    /
    if (strlen(leftPreOrder) > 0) {
        cout << "left child:" << endl;
        InitBinaryTree(T->lChild, leftPreOrder, leftInOrder);
    } else
        T->lChild = nullptr;
    if (strlen(rightPreOrder) > 0) {
        cout << "right child:" << endl;
        InitBinaryTree(T->rChild, rightPreOrder, rightInOrder);
    } else
        T->rChild = nullptr;
    cout << "return to last root" << endl;
}

void postOrder(BinaryTree &T) {
    if (T)
        postOrder(T->lChild), postOrder(T->rChild), cout << T->value;
}

void DeleteBinaryTree(BinaryTree &T) {
    if (!T)
        return;
    DeleteBinaryTree(T->lChild), DeleteBinaryTree(T->rChild);
    free(T);
    T = nullptr;
}

int main() {
    BinaryTree T;
    char pre[] = "GDAFEMHZ", in[] = "ADEFGHMZ";
    InitBinaryTree(T, pre, in);
    cout << "Post order sequence: ";
    postOrder(T);
    DeleteBinaryTree(T);
    return 0;
}

运行结果

root->G DAFE MHZ pre
ADEF root->G HMZ in

left child:
root->D A FE pre
A root->D EF in

left child:
root->A   pre
 root->A  in

return to last root
right child:
root->F E  pre
E root->F  in

left child:
root->E   pre
 root->E  in

return to last root
return to last root
return to last root
right child:
root->M H Z pre
H root->M Z in

left child:
root->H   pre
 root->H  in

return to last root
right child:
root->Z   pre
 root->Z  in

return to last root
return to last root
return to last root
Post order sequence: AEFDHZMG