Construction and traversal of binary tree

import java.util.ArrayList;

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode root;
    
    TreeNode(){}
    TreeNode(int val){
        this.val = val;
    }
    TreeNode(int val, TreeNode left,TreeNode right){
        this.val = val;
        this.right = right;
        this.left = left;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }

    //     The former sequence traversal —— recursive LC144—— Preorder traversal of two tree 
    ArrayList<Integer> preorderReverse(TreeNode root){
        ArrayList<Integer> result = new ArrayList<>();
        preOrder(root,result);
        return result;
    }
//     Recursive parameters and return types 
    void preOrder(TreeNode root,ArrayList<Integer> result){
//         Recursive termination condition 
        if (root == null){
            return;
        }
//         Recursive single-layer logic 
        result.add(root.val);
        preOrder(root.left,result);
        preOrder(root.right,result);
    }

    //  In the sequence traversal · recursive ·LC94_ Middle order traversal of binary trees 
    public ArrayList<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        inorder(root,res);
        return res;
    }

    void inorder(TreeNode root,ArrayList<Integer> list){
        if (root == null){
            return;
        }
        inorder(root.left,list);
        list.add(root.val);
        inorder(root.right,list);
    }

    //  After the sequence traversal · recursive ·LC145_ Postorder traversal of binary trees 
    public ArrayList<Integer> postorderTraversal(TreeNode root){
        ArrayList <Integer> res = new ArrayList<>();
        postorder(root,res);
        return res;
    }
    void postorder(TreeNode root,ArrayList<Integer> list){
        if (root == null){
            return;
        }
        postorder(root.left,list);
        postorder(root.right,list);
        list.add(root.val);

    }


    public void createTree(int [] nums){
//         Create a collection to save the node of the tree 
        ArrayList<TreeNode> treeNodes = new ArrayList<>();
        for (int tempdata:nums) {
            treeNodes.add(new TreeNode(tempdata));
        }
//         Set the first node as the root node 
        root = treeNodes.get(0);
    /*
    *  Use the method of building a complete binary tree to build 
    * */
        for (int i = 0; i < treeNodes.size()/2; i++) {
            if ((i*2+1)< treeNodes.size()){
                treeNodes.get(i).setLeft(treeNodes.get(i*2+1));
            }
            if ((i*2+2)< treeNodes.size()){
                treeNodes.get(i).setRight(treeNodes.get(i*2+2));
            }
        }
    }
    

    public static void main(String[] args) {
        int [] nums = {1,2,3,4,5,6,7,8};
        TreeNode treeNode = new TreeNode();
        treeNode.createTree(nums);
        ArrayList<Integer> res1 =treeNode.preorderReverse(treeNode.getRoot());
        ArrayList<Integer> res2 =treeNode.inorderTraversal(treeNode.getRoot());
        ArrayList<Integer> res3 =treeNode.postorderTraversal(treeNode.getRoot());
        System.out.println(res1);
        System.out.println(res2);
        System.out.println(res3);
    }
}

Output results ：

[1, 2, 4, 8, 5, 3, 6, 7]
[8, 4, 2, 5, 1, 6, 3, 7]
[8, 4, 5, 2, 6, 7, 3, 1]