Binary tree traversal

Child representation ：

typedef struct treeNode {
    
    char data;
    struct treeNode * lChild;
    struct treeNode * rChild;
}treeNode,* pTreeNode;

Create a tree node

pTreeNode createTreeNode(char data)
{
    
    pTreeNode p = new treeNode;
    p->data = data;
    p->lChild = nullptr;
    p->rChild = nullptr;
    return p;
}

Insert tree node

void insertTreeNode(pTreeNode parentNode,pTreeNode l,pTreeNode r)
{
    
    if(parentNode != nullptr)
    {
    
        parentNode->lChild = l;
        parentNode->rChild = r;
    }
}

Print out current tree node data

void printfCurTreeNode(pTreeNode node)
{
    
    if(nullptr != node)
    {
    
        O << node->data << " ";
    }
}

Three traversal methods , Recursive implementation

// The former sequence traversal   root   Left   Right 
void preOrder(pTreeNode root)
{
    
    if(nullptr != root)
    {
    
        printfCurTreeNode(root);
        preOrder(root->lChild);
        preOrder(root->rChild);
    }
}
// In the sequence traversal   Left   root   Right 
void midOrder(pTreeNode root)
{
    
    if(nullptr != root)
    {
    
        midOrder(root->lChild);
        printfCurTreeNode(root);
        midOrder(root->rChild);
    }
}
// After the sequence traversal   Left   Right   root 
void lastOrder(pTreeNode root)
{
    
    if(nullptr != root)
    {
    
        lastOrder(root->lChild);
        lastOrder(root->rChild);
        printfCurTreeNode(root);
    }
}

int main(int argc, char *argv[])
{
    
    QApplication a(argc, argv);
    pTreeNode A = createTreeNode('A');
    pTreeNode B = createTreeNode('B');
    pTreeNode C = createTreeNode('C');
    pTreeNode D = createTreeNode('D');
    pTreeNode E = createTreeNode('E');
    pTreeNode F = createTreeNode('F');
    pTreeNode G = createTreeNode('G');

    insertTreeNode(A,B,C);
    insertTreeNode(B,D,nullptr);
    insertTreeNode(D,nullptr,G);
    insertTreeNode(C,E,F);

    O << "\n The former sequence traversal ：\n";
    preOrder(A);
    O << " In the sequence traversal ：\n";
    midOrder(A);
    O << "\ After the sequence traversal ：\n";
    lastOrder(A);

    return 0;
}

Output effect ：