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<BTNode> 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 postOrderNonRecursive(BTNode *root) {
    if (NULL == root) {
        return;
    }

    stack<BTNode*> stackNode;
    stackNode.push(root);

    BTNode *curr=NULL
          ,*pre =NULL;
    while(!s.empty()) {
        curr=s.top();
        if((NULL == curr->lchild && NULL == curr->rchild)|| (NULL != pre &&(pre == curr->lchild || pre == curr->rchild))) {
            cout<<curr->data<<"";
            stackNode.pop();
            pre=curr;
        } else {
            if(NULL != curr->rchild) {
                stackNode.push(curr->rchild);
            }

            if(curr->lchild!=NULL){
                stackNode.push(curr->lchild);
            }
        }
    }
}


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

    BTNode* pNode = root;
    queue<BTNode> 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<BTNode> 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);
        }
    }
}