java 实现排序二叉树的插入和前序,中序,后序遍历

树节点类

package tree.demo;

public class TreeNode {

    public TreeNode(int data) {
        super();
        this.data = data;
    }

    int data;
    TreeNode left;
    TreeNode right;

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    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;
    }

}

树类

package tree.demo;

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

public class Tree {

    int size;
    TreeNode root;
    List<Integer> nodeOrder;

    /*
     * 是每个结点最多有两个子树的有序树，在使用二叉树的时候，数据并不是随便插入到节点中的，
     * 一个节点的左子节点的关键值必须小于此节点，右子节点的关键值必须大于或者是等于此节点，所以又称二叉查找树、二叉排序树、二叉搜索树
     */
    public void add(int data) {
        TreeNode newNode = new TreeNode(data);
        if (root == null) {
            root = newNode;
            size++;
        } else {
            TreeNode current = root;
            while (true) {// 没有完成插入则继续查找合适的位置插入直到插入为止才返回
                if (newNode.getData() < current.getData()) {
                    // 小于则插入改节点的左边
                    if (current.getLeft() == null) {
                        current.setLeft(newNode);
                        size++;
                        return;
                    }
                    current = current.getLeft();// 该节点以被插入则继续往下查找合适的位置插入
                } else {
                    // 大于或等于则插入改节点的左边
                    if (current.getRight() == null) {
                        current.setRight(newNode);
                        size++;
                        return;
                    }
                    current = current.getRight();// 该节点以被插入则继续往下查找合适的位置插入
                }
            }
        }

    }

    // 前序遍历：根节点->左子树->右子树
    public void prevOrder(TreeNode node, List<Integer> arr) {
        if (arr == null) {
            arr = new ArrayList<Integer>();// 初始化数组
        }
        arr.add(node.data);
        if (node.getLeft() != null) {
            prevOrder(node.getLeft(), arr);
        }
        if (node.getRight() != null) {
            prevOrder(node.getRight(), arr);
        }
        if (arr.size() == size) {
            nodeOrder = arr;
        }
    }

    // 中序遍历：左子树->根节点->右子树
    public void inOrder(TreeNode node, List<Integer> arr) {
        if (arr == null) {
            arr = new ArrayList<Integer>();// 初始化数组
        }
        if (node.getLeft() != null) {
            inOrder(node.getLeft(), arr);
        }
        arr.add(node.data);
        if (node.getRight() != null) {
            inOrder(node.getRight(), arr);
        }
        if (arr.size() == size) {
            nodeOrder = arr;
        }
    }

    // 后序遍历：左子树->右子树->根节点
    public void lastOrder(TreeNode node, List<Integer> arr) {
        if (arr == null) {
            arr = new ArrayList<Integer>();// 初始化数组
        }
        if (node.getLeft() != null) {
            lastOrder(node.getLeft(), arr);
        }
        if (node.getRight() != null) {
            lastOrder(node.getRight(), arr);
        }
        arr.add(node.data);
        if (arr.size() == size) {
            nodeOrder = arr;
        }
    }
}

执行测试类
package tree.demo;

public class Main {

public static void main(String[] args) {

    int[] num = new int[] { 10, 18, 3, 8, 12, 2, 7 };
    // 前序遍历：根节点->左子树->右子树
    // 前序 10 3 2 8 7 18 12
    // 中序遍历：左子树->根节点->右子树
    // 中序 2 3 7 8 10 12 18
    // 后序遍历：左子树->右子树->根节点
    // 后序 2 7 8 3 12 18 10
    Tree t = new Tree();
    for (int i = 0; i < num.length; i++) {
        t.add(num[i]);
    }
    // System.out.println("debug");
    t.prevOrder(t.root, null);
    for (int i = 0; i < t.nodeOrder.size(); i++) {
        System.out.print(t.nodeOrder.get(i) + "\t");
    }
    // 10 3 2 8 7 18 12
    System.out.println("");
    t.inOrder(t.root, null);
    for (int i = 0; i < t.nodeOrder.size(); i++) {
        System.out.print(t.nodeOrder.get(i) + "\t");
    }
    // 2 3 7 8 10 12 18
    System.out.println("");
    t.lastOrder(t.root, null);
    for (int i = 0; i < t.nodeOrder.size(); i++) {
        System.out.print(t.nodeOrder.get(i) + "\t");
    }
    // 2 7 8 3 12 18 10
    System.out.println("");

}

}

执行结果
10 3 2 8 7 18 12
2 3 7 8 10 12 18
2 7 8 3 12 18 10