树 相关知识总结以及Java实现

最近在温习树相关的知识，并且用java实现了一下树的遍历相关，先贴上代码供大家参考吧。

package tree_problems;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Queue;
import java.util.Stack;

public class TreeNodec<E> {
    E value;
    TreeNodec<E> left;
    TreeNodec<E> right;
    public TreeNodec(E x){value=x;}

    private static <E> void forPreOrderRecursion(TreeNodec<E> T,ArrayList<E> result) {    //静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
        if(T!=null) {
            result.add(T.value);
            forPreOrderRecursion(T.left, result);
            forPreOrderRecursion(T.right, result);
        }
    }
    public static <E> ArrayList<E> preOrderRecursion(TreeNodec<E> T) {
        ArrayList<E> result = new ArrayList<>();
        forPreOrderRecursion(T, result);
        return result;
    }
    private static <E> void forInOrderRecursion(TreeNodec<E> T,ArrayList<E> result) {    //静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
        if(T!=null) {
            forInOrderRecursion(T.left, result);
            result.add(T.value);
            forInOrderRecursion(T.right, result);
        }
    }
    public static <E> ArrayList<E> inOrderRecursion(TreeNodec<E> T) {
        ArrayList<E> result = new ArrayList<>();
        forInOrderRecursion(T, result);
        return result;
    }
    private static <E> void forPostOrderRecursion(TreeNodec<E> T,ArrayList<E> result) {    //静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
        if(T!=null) {
            forPostOrderRecursion(T.left, result);
            forPostOrderRecursion(T.right, result);
            result.add(T.value);
        }
    }
    public static <E> ArrayList<E> postOrderRecursion(TreeNodec<E> T) {
        ArrayList<E> result = new ArrayList<>();
        forPostOrderRecursion(T, result);
        return result;
    }
    //非递归前序遍历
    public static <E> ArrayList<E> preOrder(TreeNodec<E> T){
        Stack<TreeNodec> stack = new Stack<>();
        ArrayList<E> result = new ArrayList<>();
        TreeNodec<E> p =T;    //工作指针
        while(p!=null||!stack.empty()) {    //NLR，先读N，后进栈L和R
            if(p!=null) {
                result.add(p.value);
                stack.push(p);
                p=p.left;
            }
            else {
                p=stack.pop().right;
            }
        }
        return result;
    }
    public static <E> ArrayList<E> inOrder(TreeNodec<E> T){
        Stack<TreeNodec> stack = new Stack<>();
        ArrayList<E> result = new ArrayList<>();
        TreeNodec<E> p =T;    //工作指针
        while(p!=null||!stack.empty()) {    //LNR，先进栈L，再读，最后再进栈R
            if(p!=null) {
                stack.push(p);
                p=p.left;
            }
            else {
                p=stack.pop();
                result.add(p.value);
                p=p.right;
            }
        }
        return result;
    }
    public static <E> ArrayList<E> postOrder(TreeNodec<E> T){//LRN和NRL结果倒过来一样，NRL和NLR又有什么区别呢……其实就是前序遍历啊……
        Stack<TreeNodec> stack = new Stack<>();
        ArrayList<E> result = new ArrayList<>();
        TreeNodec<E> p =T;    //工作指针
        while(p!=null||!stack.empty()) {
            if(p!=null) {
                result.add(0,p.value);
                stack.push(p);
                p=p.right;
            }
            else {
                p=stack.pop().left;
            }
        }
        return result;
    }
    public static <E> ArrayList<E> postOrdersb(TreeNodec<E> T){//傻了，LRN和NRL结果倒过来一样，NRL和NLR又有什么区别呢……其实就是前序遍历啊……
        Stack<TreeNodec> stack = new Stack<>();
        Stack<E> values = new Stack<>();
        ArrayList<E> result = new ArrayList<>();
        TreeNodec<E> p =T;    //工作指针
        while(p!=null||!stack.empty()) {    //LRN，先进栈(倒序NRL进栈），最后再读，用栈1负责顺序，用栈2负责读结果（如果用自己手动的栈可以将两个栈合并为1个）
            if(p!=null) {
                stack.push(p);
                values.push(p.value);
                p=p.right;
            }
            else {
                p=stack.pop();
                p=p.left;
            }
        }
        while(!values.empty()) {
            result.add(values.pop());
        }
        return result;
    }
    public static <E> ArrayList<E> levelTraverse(TreeNodec<E> T){
        ArrayList<E> result = new ArrayList<>();
        Queue<TreeNodec<E>> queue = new ArrayDeque<>();
        queue.add(T);
        TreeNodec<E> p = T;
        while(!queue.isEmpty()) {
            p = queue.remove();
            result.add(p.value);
            if(p.left!=null) queue.add(p.left);
            if(p.right!=null) queue.add(p.right);
        }
        return result;
    }

    public static void main(String[] args) {
        TreeNodec<Integer> T = new TreeNodec(1);
        T.left = new TreeNodec(2);T.right = new TreeNodec(3);
        T.left.right = new TreeNodec(4);T.left.right.left = new TreeNodec(6);
        T.right.right = new TreeNodec(5);
        ArrayList<Integer> preorder = TreeNodec.preOrderRecursion(T);
        System.out.println(preorder);
        ArrayList<Integer> inorder = TreeNodec.inOrderRecursion(T);
        System.out.println(inorder);
        ArrayList<Integer> postorder = TreeNodec.postOrderRecursion(T);
        System.out.println(postorder);
        ArrayList<Integer> prorder = TreeNodec.preOrder(T);
        System.out.println(prorder);
        ArrayList<Integer> iorder = TreeNodec.inOrder(T);
        System.out.println(iorder);
        ArrayList<Integer> porder = TreeNodec.postOrder(T);
        System.out.println(porder);
        ArrayList<Integer> levelTraversal = TreeNodec.levelTraverse(T);
        System.out.println(levelTraversal);
    }
}