二叉树的遍历

定义二叉树结点

typedef struct Node{                    
    struct Node *lchild;
    char data;    
    struct Node *rchild;
}BTNode;

 

//层次遍历 
void levelOrder(BTNode* root){
    if(root==NULL){
        return root;
    }
    Queue<BTNode*> queue = new Queue<>();                                                              
    in(queue,root); //根入队列    
   //一次循环出一个顶元素，出来的时候，把俩儿子（左在列前，右在列后）放进去。
    while(!isEmpty(queue)){                    
        BTNode*tmp = out(queue);                          
        printf("%c",tmp->data); 
        if(tmp->lchild!=NULL){                   
            in(queue,tmp->lchild);
        }
        if(tmp->rchild!=NULL){                 
            in(queue,tmp->rchild);
        }                                       
    }                                             
}

 

//先序递归遍历（即是深度优先遍历）
void preOrder(BTNode* root ){
    if(root!=NULL){                            
        printf("%c",root->data); //访问根节点
        preOrder(root->lchild); //递归，先序遍历左子树 
        preOrder(root->rchild); //递归，先序遍历右子树 
    }
}
//先序非递归遍历
void preOrder(BTNode* root) {
    if (root == null) {
        return;
    }
    Stack<BTNode*> stack = new Stack<>();
    add(root);//根入
    //一次出一个，出来的时候，把俩儿子（左在栈上，右在栈下）放进去。
    while (!isEmpty(queue)) {
        BTNode* tmp = pop(stack);
        printf("%c",tmp->data);
        if (tmp->rchild != null) { //右孩子压底备用
            push(stack,tmp->rchild);
        }
        if (tmp->lchild != null) {
            push(stack,tmp->lchild);
        }
    }
}

 

//中序递归遍历
void  middleOrder(BTNode * root){
    if(root!=NULL){                            
        middleOrder(root->lchild); //递归，中序遍历左子树 
        printf("%c",root->data); //访问根节点
        middleOrder(root->rchild); //递归，中序遍历右子树 
    }
} 

//中序非递归遍历
void middleOrder(BTNode* root) {
    if (root == null) {
        return;
    }
    Stack<TreeNode> stack = new Stack<>();
    TreeNode* tmp = root;
    while (tmp != NULL || !isEmpty(stack)) { 
        while (tmp != NULL) { //首次循环，左节点全部压入栈(左先)
            push(stack,tmp);
            tmp = tmp->lchild;
        }
        if (!isEmpty(stack)) {
            tmp = pop(stack); //首次循环，弹出最左边的节点
            printf("%c",tmp.data);
            tmp = tmp->rchild; //弹出左，顾其右（右为空，不压入，继续弹上左。）
        }
    }
} 

 

//后序递归遍历
void postOrder(BTNode * pBt){
    if(pBt!=NULL){
        postOrder(pBt->lchild);
        postOrder(pBt->rchild);
        printf("%c",pBt->data);
    }
}

//后序非递归遍历
void postOrder(BTNode* root) {
    if(root == null) {
        return;
    }
    Stack<BTNode*> stackTmp = new Stack<>();
    Stack<BTNode*> stackRes = new Stack<>();
    push(stackTmp,root);
    while (!isEmpty(stackTmp)) {
        BTNode* tmp = pop(stack1);
        push(stackRes,tmp); //将弹出的元素加到stackRes中,最后再输出。
        if (tmp->lchild != null) { //（左在临时栈下，右在临时栈上）
            push(stackTmp,tmp->lchild);
        }
        if (tmp->rchild != null) { 
            push(stackTmp,tmp->rchild);
        }
    }
    while (!isEmpty(stackRes)) {
       printf("%c",pop(stackRes)->data);
    }
}