CPP:Binary Tree

void preOrderTraversal(BTNode *root) {  
    if(NULL == root) {
        return;
    }

    printf("%d ", root->val);
    preOrderTraversal(root->lChild);
    preOrderTraversal(root->rChild);
}


void inOrderTraversal(BTNode *root) {  
    if(NULL == root) {
        return;
    }

    inOrderTraversal(root->lChild);
    printf("%d ", root->val); 
    inOrderTraversal(root->rChild);
}  


void postOrderTraversal(BTNode *root) {
    if(NULL == root) {
        return;
    }

    postOrderTraversal(root->lChild);
    postOrderTraversal(root->rChild); 
    printf("%d ", root->val);
}


void inOrderTraversalNonRecursive(BTNode *root) {  
    if(NULL == root) {
        return;
    }

    BTNode *curr = root;
    stack<BTree> s;
    while(NULL != curr || !s.empty()) {
        while(curr != NULL) {
            s.push(curr);
            curr = curr->lChild;
        }

        if(!s.empty()){
            curr = s.pop();
            cout<<curr->data<<"  ";
            curr = curr->rChild;
        }
    }
}


void leverTraversal(BTNode* root) {
    if (NULL == root) {
        return root;
    }

    BTNode* pNode = root;
    queue<BTree> queueNode;
    queueNode.push(p);


    while(!queueNode.empty()) {
        pNode = queueNode.pop();
        if(NULL != pNode->lchild) {
            queueNode.push(p->lchild);
        }

        if(visit(pNode->rchild) == 1) {
            queueNode.push(p->rchild);
        }
    }  
}


void depthTraversal(BTNode* root){
    if (NULL == root) {
        return root;
    }

    stack<BTree> stackNode;
    stackNode.push(root);
    Node *node = NULL;

    while(!stackNode.empty()){
        node = stackNode.pop();
        printf("%d ", node->val);
        if(node->rChild){
            stackNode.push(node->rChild);
        }
        if(node->lChild){
            stackNode.push(node->lChild);
        }
    }
}