二叉树Java实现

二叉树

package com.zhihong;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class BinTreeTraverse {
    
    
    private int[] array = {
    
    1, 2, 3, 4, 5, 6, 7, 8, 9};
    private static List<Node> nodeList = null;
    private Node root;
    private class Node {
    
    
        private Node leftChild;
        private Node rightChild;
        private Object data;

        private Node(int newData) {
    
    
            leftChild = null;
            rightChild = null;
            data = newData;
        }
    }

    public void createBinTree() {
    
    
        nodeList = new ArrayList<>();
        for (int i : array) {
    
    
            nodeList.add(new Node(i));
        }
        root = nodeList.get(0);

        for (int i = 0; i < nodeList.size() / 2; i++) {
    
    

            nodeList.get(i).leftChild = nodeList.get((i << 1) + 1);

            if((i << 1) + 2 < nodeList.size()) {
    
    
                nodeList.get(i).rightChild = nodeList.get((i << 1) + 2);
            }
        }

    }

    // 先序遍历
    public void preOrder(Node node) {
    
    
        if(node == null) {
    
    
            return;
        }
        System.out.println(node.data);
        preOrder(node.leftChild);
        preOrder(node.rightChild);
    }
    // 中序遍历
    public void infixOrder(Node node) {
    
    
        if (node == null) {
    
    
            return;
        }
        infixOrder(node.leftChild);
        System.out.println(node.data);
        infixOrder(node.rightChild);
    }
    // 后序遍历
    public void afterOrder(Node node) {
    
    
        if(node == null) {
    
    
            return;
        }
        afterOrder(node.leftChild);
        afterOrder(node.rightChild);
        System.out.println(node.data);
    }

    public static void main(String[] args) {
    
    
        BinTreeTraverse binTreeTraverse = new BinTreeTraverse();
        binTreeTraverse.createBinTree();
        binTreeTraverse.afterOrder(binTreeTraverse.root);
    }
}

解析：最后一个结点必定为叶节点 == nodeList.size, 那么最后一个有子节点的节点 i < nodeList.siez / 2.