实现二叉树的基本操作(Java版)

近期研究了一下二叉树，试着用Java语言实现了二叉树的基本操作，下面分享一下实现代码：

package com.sf.test;

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Stack;

public class TreeMain {
    
    public static void main(String[] agrs) {
        int[] arr = {5,17,15,19,4,8,7,10,9,14,16};
        TreeNode root = new TreeNode();
        root.data = 11;
        System.out.println("TreeMain start");
        //创建二叉树
        for(int item :arr) {
            createTree(root,item);
        }
        
        //先序遍历
        System.out.println("先序遍历:");
        preOrderTraverse(root);
        
        System.out.println("中序遍历");
        //中序遍历
        midOrderTraverse(root);
        
        System.out.println("后序遍历");
        //后序遍历
        postOrderTraverse(root);
        
        System.out.println("广度遍历");
        //广度遍历
        layOrderTraverse(root);
        
        System.out.println("深度遍历");
        //深度遍历
        deepOrderTraverse(root);
        
        //查找节点
        find(root,10);
        
        System.out.println("树的高度:"+height(root));
        
        System.out.println("TreeMain end");
    }
    
    /**
     * 根据现有数据 生成二叉树 
     * @param node
     * @param data
     */
    public static TreeNode createTree(TreeNode node,int data) {
        if(null==node) {
            node = new TreeNode();
            node.data = data;
            return node;
        }else {
            if(data>node.data){
                node.right = createTree(node.right,data);
            }else {
                node.left = createTree(node.left,data);
                
            }
        }
        return node;
    }
    
    /**
     * 先序遍历
     * @param node
     */
    public static void preOrderTraverse(TreeNode node) {
        if(null==node) {
            return;
        }
        System.out.println(node.data+",");
        preOrderTraverse(node.left);
        preOrderTraverse(node.right);
    }
    
    /**
     * 中序遍历
     * @param node
     */
    public static void midOrderTraverse(TreeNode node) {
        if(null==node) {
            return;
        }
        midOrderTraverse(node.left);
        System.out.println(node.data+",");
        midOrderTraverse(node.right);
    }
    
    /**
     * 后序遍历
     * @param node
     */
    public static void postOrderTraverse(TreeNode node) {
        if(null==node) {
            return;
        }
        postOrderTraverse(node.left);
        postOrderTraverse(node.right);
        System.out.println(node.data+",");
    }
    
    /**
     * 广度遍历
     * @param root
     */
    public static void layOrderTraverse(TreeNode root) {
        Queue<TreeNode> q = new ArrayDeque<>();
        if(null!=root) {
            System.out.println(root.data);
            q.add(root.left);
            q.add(root.right);
            while(!q.isEmpty()) {
                TreeNode node = q.poll();
                System.out.println(node.data);
                if(null!=node.left) {
                    q.add(node.left);
                }
                if(null!=node.right) {
                    q.add(node.right);
                }
            }
        }
    }
    
    /**
     * 深度遍历
     * @param root
     */
    public static void deepOrderTraverse(TreeNode root) {
        Stack<TreeNode> q = new Stack<>();
        if(null!=root) {
            System.out.println(root.data);
            q.push(root.right);
            q.push(root.left);
            while(!q.isEmpty()) {
                TreeNode node = q.pop();
                System.out.println(node.data);
                if(null!=node.right) {
                    q.push(node.right);
                }
                if(null!=node.left) {
                    q.push(node.left);
                }
            }
        }
    }
    
    /**
     * 查找节点
     * @param root 根节点
     * @param data  数据
     */
    public static void find(TreeNode node,int data) {
        if(null==node) {
            System.out.println("没有找到节点");
            return ;
        }
        if(data>node.data){
            find(node.right,data);
        }else if(data<node.data){
            find(node.left,data);
        }else {
            System.out.println("找到节点："+data);
        }
    }
    
    /**
     * 删除节点
     * @param root 根节点
     * @param data  数据
     */
    public static void delete(TreeNode node,int data) {
        if(null==node) {
            System.out.println("没有找到节点");
            return ;
        }
        if(data>node.data){
            find(node.right,data);
        }else if(data<node.data){
            find(node.left,data);
        }else {
            System.out.println("找到节点："+data);
            if(null==node.left||null==node.right) {
                //直接删除节点，
            }else {
                //取右子树最大的节点替换此节点，自己去实现了（哈哈）
            }
        }
    }
    
    /**
     * 求树的高度
     * @param node
     * @return
     */
    public static int height(TreeNode node) {
        if(null==node) {
            return 0;
        }
        int hLeft = height(node.left) +1;
        int hRight = height(node.right)+1;
        return hLeft>hRight?hLeft:hRight;
    }

}

节点实体：

为了操作方便，属性都定义成public了，实际应用还是定义为private

package com.sf.test;

public class TreeNode {
    
    //数据
    public int data;
    
    //左节点
    public TreeNode left;
    
    //右节点
    public TreeNode right;
    
}

二叉树的相关算法还是有点复杂的，要经常温习，一段时间不用基本上就忘了，所以我用博客记录下来实现的过程，并与大家分享。