java数据结构和算法05（二叉树）

package com.wyq.test;

import com.wyq.test.MyTree.Node;

public class MyTree {
    private Node root;
    
    public static class Node{
        private Integer key;    //节点中存的数据
        private Node leftChild;//左子结点
        private Node rightChild;//右子节点
        
        
        public Node(Integer key) {
            this.key = key;
            this.leftChild = null;
            this.rightChild = null;
        }


        public void displayNode(){
            System.out.println("{"+key+"}");
        }
    }
    
    public boolean add(int value){
        Node newNode = new Node(value);
        if (root==null) {
            root = newNode;
            return true;
        }else{
            Node parentNode = null;
            Node current = root;
            while(current!=null){
                parentNode = current;
                if (value<current.key) {
                    current = parentNode.leftChild;
                    if (current==null) {
                        parentNode.leftChild = newNode;
                        return true;
                    }
                }else{
                    current = parentNode.rightChild;
                    if (current==null) {
                        parentNode.rightChild = newNode;
                        return true;
                    }
                }
            
            }
            
        }
        return false;
    }
    //中序遍历树中的所有数据
    public void infixOrder(Node node){
        if (node!=null) {
            infixOrder(node.leftChild);
            node.displayNode();
            infixOrder(node.rightChild);
        }
    }
    //根据数据查找对应的节点
    public Node find(Integer value){
        Node current = root;
        while(current!=null){
            if (value<current.key) {
                current = current.leftChild;
            }else if (value>current.key) {
                current = current.rightChild;
            }else{
                return current;
            }
        }
        return null;
    }
    //查询树中最大值
    public Node findMax(){
        Node current = root;
        Node max=null;
        while(current!=null){
            max = current;
            current = current.leftChild;
        }
        return max;
    }
    //查询书中最小值
    public Node findMin(){
        Node current = root;
        Node min = null;
        while(current!=null){
            min = current;
            current = current.rightChild;
        }
        return min;
    }
    //根据数据删除对应的节点
    public boolean delete(int value){
        Node parent = null;
        Node current = root;
        Boolean isLeftChild = null;
        //当根节点不存在的时候，执行删除操作会抛出异常
        if (root==null) {
            try {
                throw new Exception("树中没有数据，你删除空气啊！");
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }
        //这里只是移动了parent和current的指针，首先是判断节点是在根节点的左边还是右边，确定了之后再慢慢往下找，最后将current移动到被删除的节点那里，
        //后面我们就可以通过current这个指针获取删除节点的信息;
        //如果最后current==null了，说明最后没有找到该节点，就返回false
        while(value!=current.key){
            parent = current;
            if (value<current.key) {
                isLeftChild = true;
                current = current.leftChild;
            }else{
                isLeftChild = false;
                current = current.rightChild;
            }
            if (current==null) {
                return false;
            }
        }
        
        //如果当前被删除的节点没有子节点
        if (current.leftChild==null && current.rightChild==null) {
            if (current==root) {
                root = null;
            }else if (isLeftChild) {
                parent.leftChild = null;
            }else {
                parent.rightChild = null;
            }
            return true;
        }
        
        //假如当前被删除的节点有一个子节点，这个时候要区分子节点是左子节点还是右子节点
        //假如是左子节点
        if(current.leftChild!=null && current.rightChild==null){
            if (current == root) {
                root = current.leftChild;
            }else if (isLeftChild) {
                parent.leftChild = current.leftChild;
            }else{
                parent.rightChild = current.rightChild;
            }
            return true;
        }
        if(current.leftChild==null && current.rightChild!=null){
            //假如是右子节点，相当于条件是current.leftChild==null && current.rightChild！=null
            if (current==root) {
                root = current.rightChild;
            }else if (isLeftChild) {
                parent.leftChild = current.rightChild;
            }else{
                parent.rightChild = current.rightChild;
            }
            return true;
        }
        
        //假如被删除的节点有两个子节点,这个时候我们首先就要找后继节点，我们写一个找后继节点的方法getAfterNode（）
        if (current.leftChild!=null && current.rightChild!=null) {
            Node success = getAfterNode(current);
            if (current == root) {
                root = success;
            }else if(isLeftChild){
                parent.leftChild = success;
            }else{
                parent.rightChild = success;
            }
            return true;
        }
        return false;
    }
    //根据删除节点寻找后继节点,注意，这里的话delNode肯定要有两个子节点，假如没有，那就是前面的两种删除节点的情况了
    public Node getAfterNode(Node delNode){
        Node successParent = delNode;
        Node success = delNode;
        Node current = delNode.leftChild;
        while(current!=null){
            successParent = success;
            success = current;
            current = current.leftChild;
        }
        
        if (success!=delNode) {
            successParent.leftChild = success.rightChild;
            success.rightChild = delNode.rightChild;
        }
        return success;
    }
    
    public static void main(String[] args) {
        MyTree tree = new MyTree();
        tree.add(100);
        tree.add(50);
        tree.add(200);
        tree.add(25);
        tree.add(75);
        tree.add(150);
        tree.add(250);
        
        tree.delete(200);
        tree.infixOrder(tree.root);
        
        Node find = tree.find(250);
        System.out.print("查找节点数据:");
        find.displayNode();
        
        System.out.print("最大值为：");
        tree.findMax().displayNode();
        
        System.out.print("最小值为：");
        tree.findMin().displayNode();
    }
    
}