Java构建有序二叉树，使用递归与非递归方式

目录

树的概念

实现

封装一个结点类

创建一个二叉树管理类，并在其中编写构建二叉树的方法

使用递归方式构建二叉树

编写测试类

测试结果，成功

---

树的概念

树(Tree)是n(n≧0)个结点的有限集。

在任意一颗非空树中：有且仅有一个特定的称为根的结点。n=0时称为空树。

• n=0时称为空树。
• n>1时，其余结点可分为m(m>0)个互不相交的有限集T1，T2，T3，……，Tm，其中每个集合本身又是一棵树，并且称为根的子树。

二叉树

       每个节点的度最大为2 （最多拥有2棵子树）。

       左子树和右子树是有顺序的。

       即使某节点只有一棵子树，也要区分左右子树。

实现

封装一个结点类

package com.mine.tree;

public class TreeNode {
    private TreeNode leftTreeNode;
    private TreeNode rightTreeNode;
    private Integer value;

    public TreeNode(Integer value) {
        this.value = value;
    }

    public TreeNode getLeftTreeNode() {
        return leftTreeNode;
    }

    public void setLeftTreeNode(TreeNode leftTreeNode) {
        this.leftTreeNode = leftTreeNode;
    }

    public TreeNode getRightTreeNode() {
        return rightTreeNode;
    }

    public void setRightTreeNode(TreeNode rightTreeNode) {
        this.rightTreeNode = rightTreeNode;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "TreeNode{" +
                "value=" + value +
                ", leftTreeNode=" + leftTreeNode +
                ", rightTreeNode=" + rightTreeNode +
                '}';
    }
}

创建一个二叉树管理类，并在其中编写构建二叉树的方法

package com.mine.tree;

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

public class BinaryTree {

    public TreeNode root;

    public void insert(Integer value) {
        //创建一个节点
        TreeNode newNode = new TreeNode(value);
        if (root == null) {
            root = newNode;
            return;
        }
        //定义一个游标来遍历整个二叉树
        TreeNode currentNode = root;
        //定义一个游标来记录currentNode的前一个地址
        TreeNode preNode = null;

        while (true) {
            preNode = currentNode;
            //判断currentNode指向的值和value进行对比
            if (newNode.getValue() > currentNode.getValue()) {
                // 游标需要先往右走
                currentNode = currentNode.getRightTreeNode();
                if (currentNode == null) {
                    preNode.setRightTreeNode(newNode);
                    return;
                }
            } else {
                currentNode = currentNode.getLeftTreeNode();
                if (currentNode == null) {
                    preNode.setLeftTreeNode(newNode);
                    return;
                }
            }
        }

    }
}

使用递归方式构建二叉树

//递归构建有序二叉树
    public void insertDiGui(TreeNode node, Integer value) {
        //新建节点
        TreeNode newNode = new TreeNode(value);

        //非递归出口
        if (root == null) {
            root = newNode;
            return;
        }

        if (node.getValue() > value) {
            if (node.getLeftTreeNode() == null) {
                node.setLeftTreeNode(newNode);
                //出口
                return;
            }
            insertDiGui(node.getLeftTreeNode(), value);
        } else {
            if (node.getRightTreeNode() == null) {
                node.setRightTreeNode(newNode);
                //出口
                return;
            }
            insertDiGui(node.getRightTreeNode(), value);
        }

    }

编写测试类

package com.mine.tree;

public class Test {
    public static void main(String[] args) {

        BinaryTree bt = new BinaryTree();
        BinaryTree bt1 = new BinaryTree();

        //普通方法构建有序二叉树
        bt.insert(5);
        bt.insert(7);
        bt.insert(4);
        bt.insert(2);
        bt.insert(0);
        bt.insert(3);

        //递归构建有序二叉树
        bt1.insertDiGui(bt1.root,5);
        bt1.insertDiGui(bt1.root,7);
        bt1.insertDiGui(bt1.root,4);
        bt1.insertDiGui(bt1.root,2);
        bt1.insertDiGui(bt1.root,0);
        bt1.insertDiGui(bt1.root,3);

        System.out.println(bt.root);
        System.out.println("==================================");
        System.out.println(bt1.root);

    }
}

测试结果，成功