树的创建和遍历

二叉树在数据结构中比较重要，特别是二叉树的创建和遍历。

首先，定义节点数据结构：

public class Node{
    public String element;
    public Node left;
    public Node right;
    
    public Node(){
        
    }
}

创建与遍历：

import java.util.Stack;
public class BTree extends Node{
    static int order = 0;
    //先序创建二叉树，“#”为null
    public Node creatTree(Node root,String[] s,int i){
        //System.out.println(i + "v:" + s[i]);
        if(i < s.length){
            if(s[i] == "#"){
                root = null;
            }else{
                Node left = new Node();
                Node right = new Node();
                root.element = s[order];
                //递归
                root.left = creatTree(left,s,++order);
                root.right = creatTree(right,s,++order);
            }
        }
        return root;
    }
    //先序遍历递归
    public void FSearch(Node root){
        if(root == null){
            return;
        }
        System.out.print(root.element);
        FSearch(root.left);
        FSearch(root.right);
    }
    //先序遍历非递归
    public void NFSearch(Node root){
        Stack<Node> stack = new Stack<Node>();
        if(root != null){
            stack.push(root);
            while(!stack.isEmpty()){
                root = stack.pop();
                System.out.print(root.element);
                //先进后出，所以先入栈右子树
                if(root.right != null){
                    stack.push(root.right);
                }
                if(root.left != null){
                    stack.push(root.left);
                }
            }
        }
    }
    //中序遍历
    public void MSearch(Node root){
        if(root == null){
            return;
        }
        MSearch(root.left);
        System.out.print(root.element);
        MSearch(root.right);
    }
    //中序遍历非递归
    public void NMSearch(Node root){
        Stack<Node> stack = new Stack<Node>();
        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);
                root = root.left;
            }
            if(!stack.isEmpty()){
                root = stack.pop();
                System.out.print(root.element);
                //访问右子树
                root = root.right;
            }
        }
    }
    //后序遍历
    public void ESearch(Node root){
        if(root == null){
            return;
        }
        ESearch(root.left);
        ESearch(root.right);
        System.out.print(root.element);
    }
    //后序遍历非递归
    public void NESerach(Node root){
        Stack<Node> stack = new Stack<Node>();
        Node node = root, prev = root; 
        while(node != null || !stack.isEmpty()){
            while(node != null){
                stack.push(node);
                node = node.left;
            }
            if(!stack.isEmpty()){
                Node temp = stack.peek().right;
                //需要注意的是，整个过程中根节点会被访问两次。最后访问的时候，如果没有（temp == prev）的判断，会进入死循环。
                if (temp == null || temp == prev) {
                    node = stack.pop();
                    System.out.print(node.element);
                    prev = node;
                    //弹出的node，不再进入循环
                    node = null; 
                }else {
                    node = temp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        Node root = new Node();
        String[] s = {"A","B","D","E","#","#","#","#","C","F","#","#","G","#","#"};
        
        BTree tree = new BTree();
        root = tree.creatTree(root,s,0);
        System.out.println("先序递归：");
        tree.FSearch(root);
        System.out.println();
        System.out.println("先序非递归：");
        tree.NFSearch(root);
        System.out.println();
        System.out.println("中序：");
        tree.MSearch(root);
        System.out.println();
        System.out.println("中序非递归：");
        tree.NMSearch(root);
        System.out.println();
        System.out.println("后序：");
        tree.ESearch(root);
        System.out.println();
        System.out.println("后序非递归：");
        tree.NESerach(root);
    }
}