//二叉搜索树
package com.weyan;

import java.util.Comparator;

@SuppressWarnings("unused")

public class BinarySearchTree<E> {
    
    private int size;
    //根节点
    private Node<E> root;
    private Comparator<E> comparator;
    
    //构造函数 不传入参数
    public BinarySearchTree() {
        this(null);
    }
    //构造函数 传入参数：比较器
    public BinarySearchTree(Comparator<E> comparator) {
        this.comparator = comparator;
    }
    
    public int size() {
        return size;
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public void clear() {
        
    }
    
    public void add(E element) {
        elementNotNullCheck(element);
        //添加第一个节点
        if (root == null) {
            root = new Node<>(element, null);
            size ++;
            return;
        }
        //添加的不是第一个节点
        //找到父节点
        Node<E> parent = root;
        Node<E> node = root;
        int cmp = 0;
        while (node != null) {
            parent = node;
            cmp = compare(element, node.element);
            if (cmp > 0) {
                node = node.right;
            }else if(cmp < 0) {
                node = node.left;
            }else {//相等
                return;
            }
        }
        //看看插入到父节点的哪个位置
        Node<E> newNode = new Node<E>(element, parent);
        if (cmp > 0) {
            parent.right = newNode;
        }else if(cmp < 0) {
            parent.left = newNode;
        }
        size ++;
    }
    
    public void remove(E element) {
        
    }
    
    public boolean contains(E element) {
        return false;
    }
    
    //比较两个节点,返回值==0代表e1和e2相等;返回值>0代表e1>e2;返回值<0代表e1<e2
    @SuppressWarnings("unchecked")
    private int compare(E e1 , E e2) {
        if (comparator != null) {
            return comparator.compare(e1, e2);
        }
        return ((Comparable<E>) e1).compareTo(e2);
    
    }
    
    //判断一个节点是否为空
    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("element must not be null");
        }
    }
    
    private static class Node<E> {
        E element;
        //左子节点
        Node<E> left;
        //右子节点
        Node<E> right;
        //父节点
        Node<E> parent;
        //构造函数
        public Node(E element,Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }
    }
}

自定义Person类

//自定义Person类，并根据age比较Person大小
package com.weyan;

//实现系统的比较器Comparable中的方法：compareTo
public class Person implements Comparable<Person> {
    private int age;
    
    public Person(int age) {
        this.setAge(age);
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Person e) {
        // TODO Auto-generated method stub
        return age - e.age;
    }
    
}

Main

package com.weyan;

import java.util.Comparator;

public class Main {
    //自定义类实现比较器PersonComparator
    private static class PersonComparator implements Comparator<Person> {
        public int compare(Person e1,Person e2) {
            return e1.getAge() - e2.getAge();
        }
    }
    //自定义类实现比较器PersonComparator2
    private static class PersonComparator2 implements Comparator<Person> {
        public int compare(Person e1,Person e2) {
            return e2.getAge() - e1.getAge();
        }
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //传入比较器PersonComparator
        BinarySearchTree<Person> bst1 = new BinarySearchTree<Person>(new PersonComparator());
        bst1.add(new Person(12));
        bst1.add(new Person(15));
        //传入比较器PersonComparator2
        BinarySearchTree<Person> bst2 = new BinarySearchTree<Person>(new PersonComparator2());
        bst2.add(new Person(12));
        bst2.add(new Person(15));
        //不传入比较器
        BinarySearchTree<Person> bst3 = new BinarySearchTree<Person>();
        bst3.add(new Person(12));
        bst3.add(new Person(15));
        
        /*
         * java 中的匿名类 类似于iOS中的Block JS中的闭包(funciton)
         */
        BinarySearchTree<Person> bst4 = new BinarySearchTree<Person>(new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        bst4.add(new Person(12));
        bst4.add(new Person(15));
    }

}

二叉搜索树完整的代码

package com.weyan;

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

import com.weyan.printer.BinaryTreeInfo;

@SuppressWarnings("unused")

//使用自定义打印器 需要实现BinaryTreeInfo类中的几个方法：root/ left/ right/ string
public class BinarySearchTree<E> implements BinaryTreeInfo {

    private int size;
    // 根节点
    private Node<E> root;
    private Comparator<E> comparator;

    // 构造函数 不传入参数
    public BinarySearchTree() {
        this(null);
    }

    // 构造函数 传入参数：比较器
    public BinarySearchTree(Comparator<E> comparator) {
        this.comparator = comparator;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void clear() {
        root = null;
        size = 0;
    }

    public void add(E element) {
        elementNotNullCheck(element);
        // 添加第一个节点
        if (root == null) {
            root = new Node<>(element, null);
            size++;
            return;
        }
        // 添加的不是第一个节点
        // 找到父节点
        Node<E> parent = root;
        Node<E> node = root;
        int cmp = 0;
        while (node != null) {
            parent = node;
            cmp = compare(element, node.element);
            if (cmp > 0) {
                node = node.right;
            } else if (cmp < 0) {
                node = node.left;
            } else {// 相等
                node.element = element;
                return;
            }
        }
        // 看看插入到父节点的哪个位置
        Node<E> newNode = new Node<E>(element, parent);
        if (cmp > 0) {
            parent.right = newNode;
        } else if (cmp < 0) {
            parent.left = newNode;
        }
        size++;
    }

    public void remove(E element) {
        remove(node(element));
    }
    
    private void remove(Node<E> node) {
        if (node == null) {
            return;
        }
        size --;
        //度为2的节点
        if (node.hasTwoChildrenNode()) {
            //找到后继节点
            Node<E> s = successor(node);
            //用后继节点的值覆盖度为2的节点的值
            node.element = s.element;
            //删除后继节点
            node = s;
        }
        //删除node节点（node的度必然是1或0）
        Node<E> replacement = node.left != null ? node.left:node.right;
        if (replacement != null) {//node是度为1节点
            //更改parent
            replacement.parent = node.parent;
            //更改parent的left/right的指向
            if (node.parent == null) {//node是度为1的节点，并且是根节点
                root = replacement;
            }else if (node == node.parent.left) {
                node.parent.left = replacement;
            }else { //node == node.parent.right
                node.parent.right = replacement;
            }
        }else if (node.parent == null) {//node是叶子节点并且是根节点
            root = null;
        }else {//node是叶子节点，但不是根节点
            if (node == node.parent.right) {
                node.parent.right = null;
            }else {//node == node.parent.left
                node.parent.left = null;
            }
        }
    }
    
    //根据元素查找对应的节点
    private Node<E> node(E element) {
        Node<E> node = root;
        while (node != null) {
            int cmp = compare(element, node.element);
            if (cmp == 0) {
                return node;
            }
            if (cmp > 0) {
                node = node.right;
            }else {
                node = node.left;
            }
        }
        return null;
    }
    ///是否包含一个元素
    public boolean contains(E element) {
        return node(element) != null;
    }

    /** ---递归写法--- **/
    // 二叉树的高度
//  public int height() {
//      return nodeHeight(root);
//  }
    // 节点高度
//  private int nodeHeight(Node<E> node) {
//      if (node == null) return 0;
//      return 1 + Math.max(nodeHeight(node.left), nodeHeight(node.right));
//  }

    /** ---层序遍历写法--- **/
    // 二叉树的高度
    public int height() {
        if (root == null)
            return 0;
        int height = 0;
        // 存储着每一层的元素数量
        int levelSize = 1;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            levelSize--;
            if (node.left != null) {
                queue.offer(node.left);
            }

            if (node.right != null) {
                queue.offer(node.right);
            }

            if (levelSize == 0) {// 意味着即将要访问下一层
                levelSize = queue.size();
                height++;
            }

        }
        return height;
    }

    // 比较两个节点,返回值==0代表e1和e2相等;返回值>0代表e1>e2;返回值<0代表e1<e2
    @SuppressWarnings("unchecked")
    private int compare(E e1, E e2) {
        if (comparator != null) {
            return comparator.compare(e1, e2);
        }
        return ((Comparable<E>) e1).compareTo(e2);

    }

    // 判断一个节点是否为空
    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("element must not be null");
        }
    }

    // 前序遍历（递归方法）
    public void preorderTraversal() {
        preorderTraversal(root);
    }

    private void preorderTraversal(Node<E> node) {
        if (node == null)
            return;
        System.out.println(node.element);
        preorderTraversal(node.left);
        preorderTraversal(node.right);
    }

    // 中序遍历（递归方法）
    public void inorderTraversal() {
        preorderTraversal(root);
    }

    private void inorderTraversal(Node<E> node) {
        if (node == null)
            return;
        preorderTraversal(node.left);
        System.out.println(node.element);
        preorderTraversal(node.right);
    }

    // 后序遍历（递归方法）
    public void postorderTraversal() {
        postorderTraversal(root);
    }

    private void postorderTraversal(Node<E> node) {
        if (node == null)
            return;
        preorderTraversal(node.left);
        preorderTraversal(node.right);
        System.out.println(node.element);
    }

    // 层序遍历(通过链表实现)
    private void levelorderTraversal() {
        if (root == null)
            return;
        Queue<Node<E>> queue = new LinkedList<>();
        // 入队
        queue.offer(root);
        while (!queue.isEmpty()) {
            // 出队
            Node<E> node = queue.poll();
            System.out.println(node.element);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

    /// 判断一棵树是否为完全二叉树
    public boolean isComplete() {
        if (root == null)
            return false;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);

        boolean leaf = false;
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            if (leaf && !node.isLeaf())
                return false;

            if (node.left != null) {
                queue.offer(node.left);
            } else if (node.right != null) {
                return false;
            }

            if (node.right != null) {
                queue.offer(node.right);
            } else {
                // 后面遍历的节点都必须是叶子节点
                leaf = true;
            }
        }

        return true;
    }

    // 前驱节点
    public Node<E> predecessor(Node<E> node) {
        if (node == null)
            return null;
        // 前驱节点在左子树当中（left.right.right.........）
        Node<E> p = node.left;
        if (p != null) {
            while (p.right != null) {
                p = p.right;
            }
            return p;
        }
        // 从父节点、祖父节点当中去找前驱节点
        while (node.parent != null && node == node.parent.right) {
            node = node.parent;
        }
        // node.parent == null && node.left == null
        return node.parent;
    }

    // 后继节点
    public Node<E> successor(Node<E> node) {
        if (node == null)
            return null;
        // 前驱节点在左子树当中（right.left.left.........）
        Node<E> p = node.right;
        if (p != null) {
            while (p.left != null) {
                p = p.left;
            }
            return p;
        }
        // 从父节点、祖父节点当中去找前驱节点
        while (node.parent != null && node == node.parent.left) {
            node = node.parent;
        }
        // node.parent == null && node.right == null
        return node.parent;
    }

    private static class Node<E> {
        E element;
        // 左子节点
        Node<E> left;
        // 右子节点
        Node<E> right;
        // 父节点
        Node<E> parent;

        // 构造函数
        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        // 是否是叶子节点
        public boolean isLeaf() {
            return left == null && right == null;
        }
        
        //度为2节点
        public boolean hasTwoChildrenNode() {
            return left != null && right != null;
        }
    }

    /*
     * 使用自定义打印器 需要实现以下几个方法
     * 
     */
    @Override
    public Object root() {
        // TODO Auto-generated method stub
        return root;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Object left(Object node) {
        // TODO Auto-generated method stub
        return ((Node<E>) node).left;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Object right(Object node) {
        // TODO Auto-generated method stub
        return ((Node<E>) node).right;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Object string(Object node) {
        // TODO Auto-generated method stub
        // 打印出parent
        Node<E> myNode = (Node<E>) node;
        String parentString = "null";
        if (myNode.parent != null) {
            parentString = myNode.parent.element.toString();
        }
        return myNode.element + "_(" + parentString + ")";
    }
}