完全二叉树代码复习用

package algorithom;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
/**
 * 定义二叉树节点元素
 * @author bubble
 *
 */
class Node {
    public Node leftchild;
    public Node rightchild;
    public int data;
    public Node(int data) {
        this.data = data;
    }
}
public class TestBinTree {
    /**
     * 将一个arry数组构建成一个完全二叉树
     * @param arr 需要构建的数组
     * @return 二叉树的根节点
     */
    public Node initBinTree(int[] arr) {
        /*数组的长度为1时返回值为自己的节点*/
        if(arr.length == 1) {
            return new Node(arr[0]);
        }
        /*数组长度不为一，则一个个加进去数组中，数组存储节点*/
        List<Node> nodeList = new ArrayList<>();
        for(int i = 0; i < arr.length; i++) {
            nodeList.add(new Node(arr[i]));
        }
        /*实现关系的依赖，因为这里是完全二叉树，所以可以用下标的方式来保证关系*/
        int temp = 0;
        /*temp可以用来定义左右孩子的位置*/
        while(temp <= (arr.length - 2) / 2) { //注意这里，数组的下标是从零开始的
            if(2 * temp + 1 < arr.length)
                /*自己节点的左孩子是多少*/
                nodeList.get(temp).leftchild = nodeList.get(2 * temp + 1);
            if(2 * temp + 2 < arr.length)
                /*自己节点的右孩子是多少*/
                nodeList.get(temp).rightchild = nodeList.get(2 * temp + 2);
                /*每次左右孩子赋值后自增操作*/
            temp++;
        }
        /*最后返回第一个节点，因为已经关联上了*/
        return nodeList.get(0);
    }
    /**
     * 层序遍历二叉树
     * @param root 二叉树根节点
     * @param nodeQueue ，用到的队列数据结构
     */
    public void trivalBinTree(Node root, Queue<Node> nodeQueue) {
        nodeQueue.add(root);
        Node temp = null;
        while ((temp = nodeQueue.poll()) != null) {
            System.out.print(temp.data + " ");
            if (temp.leftchild != null) {
                nodeQueue.add(temp.leftchild);
            }
            if (temp.rightchild != null) {
                nodeQueue.add(temp.rightchild);
            }
        }
    }
    /**
     * 先序遍历
     * @param root 二叉树根节点
     */
    public void preTrival(Node root) {
        if(root == null) {
            return;
        }
        System.out.print(root.data + " ");
        preTrival(root.leftchild);
        preTrival(root.rightchild);
    }
    /**
     * 中序遍历
     * @param root 二叉树根节点
     */
    public void midTrival(Node root) {
        if(root == null) {
            return;
        }
        midTrival(root.leftchild);
        System.out.print(root.data + " ");
        midTrival(root.rightchild);
    }
    /**
     * 后序遍历
     * @param root 二叉树根节点
     */
    public void afterTrival(Node root) {
        if(root == null) {
            return;
        }
        afterTrival(root.leftchild);
        afterTrival(root.rightchild);
        System.out.print(root.data + " ");
    }
    public static void main(String[] args) {
        TestBinTree btree = new TestBinTree();
        int[] arr = new int[] {1,2,3,4,5,6,7};
        Node root = btree.initBinTree(arr);
        Queue<Node> nodeQueue = new ArrayDeque<>();
        System.out.println("测试结果：");
        System.out.println("层序遍历：");
        btree.trivalBinTree(root, nodeQueue);
        System.out.println("\n先序遍历：");
        btree.preTrival(root);
        System.out.println("\n中序遍历：");
        btree.midTrival(root);
        System.out.println("\n后序遍历：");
        btree.afterTrival(root);
    }
}