二叉树的实现以及递归遍历

树的基本概念

​ 树（tree）可以用几种方式定义。定义树的一种自然的方式是递归。一棵树是一些结点的集合。这些集合可以是空集；若不是空集，则树由称作根的结点r以及0个或多个非空的（子）树T1, T2 …Tk 组成，这些子树中每一颗树的根都来被来自根r的一条有向边（edge）所连结。

​ 每一棵子树的根叫做根r 的儿子（child）,而r是每一棵子树的根的父亲（parent）。如图4-1显示递归定义的典型的树。

​ 从递归定义中有，一棵树是N个结点和N-1条边的集合，其中的一个结点叫做根。存在N-1条边的结论是由下面的事实得出来的： 每条边都将某个结点连接到它的父亲，而除去根节点外每一个结点都有一个父亲。

​ 如图 4-2 结点A 是根。结点B，C，H，I，P，Q，K，L,M,G 为叶子。具有相同父亲的结点为兄弟（siblings）; 例如 K,L,M均为兄弟关系。

实在懒得敲了，贴图了。

树的实现

大体思路是，创建Node 类和TreeNode类，细节看代码

Node类：

扫描二维码关注公众号，回复： 8854793 查看本文章

public class Node {
    //元素
    int data;

    //左孩子
    Node firstChild;

    //右孩子
    Node nextSibling;

    public Node getFirstChild () {
        return firstChild;
    }

    public void setFirstChild (Node firstChild) {
        this.firstChild = firstChild;
    }

    public Node getNextSibling () {
        return nextSibling;
    }

    public void setNextSibling (Node nextSibling) {
        this.nextSibling = nextSibling;
    }

    public int getData () {
        return data;
    }

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

    public Node (int data) {
        this.data = data;
    }

    //打印结点
    public void display(){
        System.out.print (data+" ");
    }
}

TreeNode类：

public class TreeNode {
    //根节点
    private Node root;

    //构建树，插入结点
    public void insert(int data){
        Node node = new Node ( data );

        //如果没有结点
        if (root == null){
            root = node;
        }
        else {
            Node current = root;
            Node parent;
            while (true){
                parent = current;   //把当前结点的引用给parent
                //比根结点值小的为左孩子，否则为右孩子
                if (data < current.getData ()){
                    current = current.getFirstChild ();     //表示把下一左引用赋值给当前左引用
                    if (current == null){
                        parent.setFirstChild ( node );  //给父结点的右孩子赋值
                        return;     //退出while循环
                    }
                }
                else {
                     current = current.getNextSibling ();
                     if (current == null){
                         parent.setNextSibling ( node );
                         return;
                     }
                }
            }
        }
    }

    public Node getRoot () {
        return root;
    }

    //先序遍历
    public void  preOrder(Node node){
        if (node != null){
            node.display ();    //打印结点
            preOrder ( node.getFirstChild ());
            preOrder ( node.getNextSibling ());
        }
    }
    //中序遍历
    public void inOrder(Node node){
        if (node != null){
            inOrder ( node.getFirstChild () );
            node.display ();
            inOrder ( node.getNextSibling () );
        }
    }
    //后续遍历
    public void endOrder(Node node){
        if (node != null){
            endOrder ( node.getFirstChild () );
            endOrder ( node.getNextSibling ());
            node.display ();
        }
    }
}

测试Test:

public class Test {
    public static void main (String[] args) {
        TreeNode treeNode = new TreeNode ();
        treeNode.insert ( 56 );
        treeNode.insert ( 23 );
        treeNode.insert ( 53 );
        treeNode.insert ( 78 );
        treeNode.insert ( 89 );

        System.out.println ("先序遍历结果为：");
        treeNode.preOrder ( treeNode.getRoot () );
        System.out.println ();
        System.out.println ("中序遍历结果为：");
        treeNode.inOrder ( treeNode.getRoot () );
        System.out.println ();
        System.out.println ("后续遍历结果为：");
        treeNode.endOrder ( treeNode.getRoot () );
    }
}

输出结果为：