数据结构-树

树的遍历：先序，中序，后序
二叉树递归形式

    void preOrder(Node root){
        if(root==null) return;
        System.out.println(root.id);
        preOrder(root.l):
        preOrder(root.r):
    }
    void midOrder(Node root){
        if(root==null) return;
        System.out.println(root.id);
        midOrder(root.l):
        midOrder(root.r):
    }
    void postOrder(Node root){
        if(root==null) return;
        System.out.println(root.id);
        postOrder(root.l):
        postOrder(root.r):
    }

一般树递归形式

    void preOrder(Node root){
        if(root==null) return;
        System.out.println(root.id);
        Node curr = root.ch;
        while(curr!=null){
            preOrder(curr);
            curr = curr.bro;
        }
    }
    void postOrder(Node root){
        if(root==null) return;
        Node curr = root.ch;
        while(curr!=null){
            postOrder(curr);
            curr = curr.bro;
        }
        System.out.println(root.id);
    }

二叉树的非递归形式

    void preOrder(Node root){
        Stack s = new Stack();
        Node curr = root;
        while(!s.isEmpty()||curr!=null){
            while(curr!=null){
                System.out.println(curr.id);
                s.push();
                curr = curr.l;
            }
            curr = s.pop();
            curr = curr.l;
        }
    }
    void midOrder(Node root){
        Stack s = new Stack();
        Node curr = root;
        while(!s.isEmpty()||curr!=null){
            while(curr!=null){
                s.push();
                curr = curr.l;
            }
            curr = s.pop();
            System.out.println(curr.id);
            curr = curr.l;
        }
    }
    void postOrder(Node root){
        Stack s1 = new Stack();
        Stack s2 = new Stack();
        Node curr = root;
        s1.push(curr);
        while(!s1.isEmpty()){
            curr = s1.pop();
            s2.push(curr);
            if(curr.l!=null) s1.push(curr.l);
            if(curr.r!=null) s1.push(curr.r);
        }
        while(!s2.isEmpty()){
            curr = s2.pop():
            System.out.println(curr.id);
        }
    }

一般树的非递归形式

    void preOrder(Node root){
        Stack s = new Stack():
        Node curr = root;
        while(!s.isEmpty()||curr!=null){
            while(curr!=null){
            System.out.println(curr.id);
                s.push(curr):
                curr = curr.ch;
            }
            curr = s.pop();
            if(curr==root){
                curr = null;
            }else{
                curr = curr.bro;
            }
        }
    }

    void postOrder(Node root){
        Stack s1 = new Stack();
        Stack s2 = new Stack();
        Node curr = root;
        s1.push(curr);
        while(!s1.isEmpty()){
            curr = s1.pop():
            s2.push(curr):
            if(curr.ch!=null){
                curr = curr.ch;
                while(curr!=null) {
                    s1.push(curr);
                    curr = curr.bro;
                }
            }
        }
        while(!s2.isEmpty()){
            curr = s2.pop();
            System.put.println(curr.id);
        }
    }