二叉排序(查找)树的实现

版权声明：版权所有，翻版我也没办法!!! https://blog.csdn.net/tebtebtebteb/article/details/82953124

二叉树排序树又称二叉查找数。它或者是一棵空数，或者是具有下列性质的二叉树：

①如果左子树不为空，那么左子树上所有节点的值均小于它的根节点的值；

②如果右子树不为空，那么右子树上所有节点的值均大于其根节点的值；

③左右子树也分别为二叉排序树

实现方法：

package com.tongtong.tree;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 二叉排序(查找)树的实现
 */
public class BinaryTree {

    private Node root;
    public BinaryTree(){
        root = null;
    }
    //将data插入到排序二叉树中
    public void insert(int data){
        Node newNode = new Node(data);
        if(root == null){
            root = newNode;
        }else{
            Node current = root;
            Node parent; //各个主节点
            while(true){ //寻找插入的位置
                parent = current;
                if(data < current.data){
                    current = current.left;
                    if(current == null){
                        parent.left = newNode;
                        return;
                    }
                }else{
                    current = current.right;
                    if(current == null){
                        parent.right = newNode;
                        return;
                    }
                }
            }
        }
    }

    //将数值输入构建二叉树
    public void buildTree(int[] data){
        for(int i=0;i<data.length;i++){
            insert(data[i]);
        }
    }

    //中序遍历方法递归实现-->左根右
    public void inOrder(Node localRoot){
        if(localRoot != null){
            inOrder(localRoot.left);
            System.out.print(localRoot.data + " ");
            inOrder(localRoot.right);
        }
    }

    public void inOrder(){
        inOrder(this.root);
    }

    //前序遍历方法递归实现-->根左右
    public void preOrder(Node localRoot){
        if(localRoot != null){
            System.out.print(localRoot.data + " ");
            preOrder(localRoot.left);
            preOrder(localRoot.right);
        }
    }

    public void preOrder(){
        preOrder(this.root);
    }

    //后序遍历方法递归实现-->左右根
    public void postOrder(Node localRoot){
        if(localRoot != null){
            postOrder(localRoot.left);
            postOrder(localRoot.right);
            System.out.print(localRoot.data + " ");
        }
    }

    public void postOrder(){
        postOrder(this.root);
    }

    //层序遍历
    public void layerTranverse(){
        if(this.root == null){
            return;
        }

        Queue<Node> q = new LinkedList<Node>();
        q.add(this.root);
        while(!q.isEmpty()){
            Node n = q.poll();
            System.out.print(n.data);
            System.out.print(" ");
            if(n.left != null) q.add(n.left);
            if(n.right != null) q.add(n.right);
        }
    }

    public static void main(String[] args) {
        BinaryTree biTree = new BinaryTree();
        int[] data = {2,8,7,4,9,3,1,6,7,5};
        biTree.buildTree(data);

        System.out.println("二叉树的中序遍历========");
        biTree.inOrder();
        System.out.println();
        System.out.println("二叉树的前序遍历========");
        biTree.preOrder();
        System.out.println();
        System.out.println("二叉树的后序遍历========");
        biTree.postOrder();
        System.out.println();
        System.out.println("层序遍历============");
        biTree.layerTranverse();
    }
}