Java 实现二叉树 kaki的博客

Java 实现二叉树 kaki的博客

二叉树图

二叉树实现代码

package com.icbc.common;

/**
 * @author Kaki Nakajima
 * @desc 二叉树
 * @date 2019.05.24
 */
public class MyTree {


    //根节点
    private Node root;

    private class Node{
        public Node(Object data){
            this.data = data;
        }

        Node left;
        Node right;
        Node parrent;
        Object data;
    }

    //查找父节点
    private Node findParrent(Node curentNode,Object data){
        Node parrent = curentNode;
        Node node = curentNode;

        while (node != null){
            //记录父节点
            parrent = node;

            //比较
            if(compare(node.data, data)){
                //左找
                node = node.left;
            }else {
                node = node.right;
            }
        }
        return parrent;

    }

    //比较大小
    private boolean compare(Object o1,Object o2){
        boolean res = false;

        if(o1 instanceof Comparable){
            Comparable c1 = (Comparable)o1;
            Comparable c2 = (Comparable)o2;
            if(c1.compareTo(c2)>0){
                res = true;
            }
        }else {
            if(o1.toString().compareTo(o2.toString())>0){
                res = true;
            }
        }
        return res;
    }

    //添加
    public void add(Object data){

        Node node = find(data);

        if(node == null){
            //不存在，就添加
            node = new Node(data);

            //判断添加在哪个位置
            if(root == null){
                root =node;
            }else {
                //查询父节点
                Node parrent = findParrent(root, data);

                node.parrent = parrent;

                //判断插在父节点的左边还是右边
                if(compare(parrent.data, data)){
                    //比父节点大，就放在父节点左边
                    parrent.left = node;
                }else {
                    //比父节点小，就放在父节点右边
                    parrent.right = node;
                }



            }
        }else {
            //该数据已存在，不添加
        }
    }

    //查找数据在二叉树中的位置
    private Node find(Object data){
        //从跟节点开始遍历
        Node temp = root;
        while (temp != null){
            if(temp.data.equals(data)&& temp.data.hashCode() == data.hashCode()){
                //找到了
                break;
            }else {
                if(compare(temp.data, data)){
                    //左边找
                    temp= temp.left;
                }else {
                    //右边找
                    temp = temp.right;
                }
            }
        }
        return temp;
    }

    // 打印
    public void print(){
        print(root);
    }

    //迭代二叉树的数据
    private void print(Node node){
        if(node == null){
            return;
        }else {
            print(node.left);
            System.out.println(node.data);
            print(node.right);
        }
    }


    public void remove(Object data) {
        // 1. 查找数据的位置
        Node node = find(data);
        // 2. 存在删除
        if (node != null) {
            // 存在
            if (node == root) {
                // 删除根节点
                if (node.left == null && node.right == null) {
                    // 没有儿子
                    root = null;
                } else if (node.left == null) {
                    // 只有右儿子
                    root = node.right;
                    root.parrent = null;
                } else if (node.right == null) {
                    // 只有左儿子
                    root = node.left;
                    root.parrent = null;
                } else {
                    // 连个儿子都有
                    Node left = splitNode(node);// 分裂节点
                    // 继位
                    root = left;
                    root.parrent = null;
                }
            } else {
                // 删除非根节点
                // 删除根节点
                if (node.left == null && node.right == null) {
                    // 没有儿子
                    // 删除node
                    if (compare(node.data, node.parrent.data)) {
                        // 在父节点的右边
                        node.parrent.right = null;
                    } else {
                        // 在父节点的左边
                        node.parrent.left = null;
                    }

                } else if (node.left == null) {
                    // 只有右儿子
                    if (compare(node.data, node.parrent.data)) {
                        // 在父节点的右边
                        node.parrent.right = node.right;
                    } else {
                        // 在父节点的左边
                        node.parrent.left =  node.right;
                    }
                    node.right.parrent = node.parrent;
                } else if (node.right == null) {
                    // 只有左儿子
                    // 只有右儿子
                    if (compare(node.data, node.parrent.data)) {
                        // 在父节点的右边
                        node.parrent.right = node.left;
                    } else {
                        // 在父节点的左边
                        node.parrent.left =  node.left;
                    }
                    node.left.parrent = node.parrent;
                } else {
                    // 连个儿子都有
                    Node left = splitNode(node);// 分裂节点
                    if (compare(left.data, node.parrent.data)) {
                        //右边
                        node.parrent.right = left;
                        left.parrent = node.parrent;
                    } else {
                        //左边
                        node.parrent.left = left;
                        left.parrent = node.parrent;
                    }
                }
            }
        }
    }

    /**
     * 分裂节点
     *
     * @param slitNode
     * @return
     */
    private Node splitNode(Node slitNode) {
        // 保留左儿子
        Node left = slitNode.left;

        // 处理右儿子节点,把右儿子放到左儿子的最右边
        Node parrent = findParrent(left, slitNode.right.data);

        // 重组节点
        parrent.right = slitNode.right;
        slitNode.right.parrent = parrent;
        return left;
    }


}

欢迎点赞关注收藏哦 ，码云搜索KakiNakajima