02_二叉搜索树基本概念及代码实现

问题引出

二叉搜索树（ Binary Search Tree Tree）

• 任意一个节点的值都 大于 其左子树所有节点的值
• 任意一个节点的值都 小于 其右子树所有节点的值

1.数据结构

• 初始化有一个为空的根节点
• 对于一个节点，肯定有父节点，而左右子树不一定有

public class BinarySearchTree<E> {
    private int size;
    private Node<E> root;

    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;
        }
    }
}

2.添加节点

• 1.判断添加的节点是否为空节点
• 2.不是空节点，判断是否为第一个加入的节点
  • 3.不是第一个节点，需要找到需要添加的呢个节点的位置（即遍历所有节点直到最后一个叶子节点则结束
    • 4.找到父节点，若元素小于它，在左边加，大于则右边加

public void add(E element){
        // 1.添加节点时候需要判断添加元素是否为空elementNotNullCheck
		elementNotNullCheck(element);
        // 2.添加第一个节点 即根节点root
        if(root == null){
            root = new Node<E>(element, null);
            size++;
            return;
        }

        // 3.否则添加不是第一个节点，需要找到需要添加位置的父节点
        Node<E> parent = null;//初始默认根节点就是父节点，然后一点点找到需要加入元素的父节点
        Node<E> node = root;
        int cmp = 0;
		// 3.1 直到遍历到最后一个不为空的节点结束
        while (node != null){
            cmp = compare(element, node.element);

            parent = node;//更新所找到的父节点

            if(cmp > 0){//新加入元素大于根节点，往右边加
                node = node.right;
            }else if(cmp < 0){//新加入元素小于根节点，往左边加
                node = node.left;
            }else {//相等
                return;
            }
        }

        // 4.找到父节点
        Node<E> newNode = new Node<>(element, parent);
        if(cmp > 0){
            parent.right = newNode;
        } else {
            parent.right = newNode;
        }
        size++;
    }

2.1添加时候判断添加元素是否为空，抛出异常即可

private void elementNotNullCheck(E element){
        if(element == null){
            throw new IllegalArgumentException("element must not be null");
        }
    }

2.2比较函数

引入比较器Comparator时，数据结构需要添加比较器的元素

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;
	}
}

• 使用comparable接口只可以实现里面一个比较方式，但是有的时候比较方式可能不同，例如下面测试中年龄的比较，需要两个比较方法，所以利用comparator比较器来实现
• 当传参时候传入比较器，则按照比较器，否则强制转换为comparable接口

/*
 * @return 返回值等于0，代表e1和e2相等；返回值大于0，代表e1大于e2；返回值小于于0，代表e1小于e2
 */
private int compare(E e1, E e2) {
	if (comparator != null) {
		return comparator.compare(e1, e2);//创建比较器
	}
	return ((Comparable<E>)e1).compareTo(e2);//实现Comparable接口，需要强制转换
}

3.测试

Comparator的两种使用方式匿名类、内部类

// 1.使用匿名类
BinarySearchTree<Person> bst2 = new BinarySearchTree<>(new Comparator<Person>() {
	public int compare(Person o1, Person o2) {
		return o2.getAge() - o1.getAge();
	}
});
for (int i = 0; i < data.length; i++) {
	bst2.add(new Person(data[i]));
}

// 2. 创建内部类，两种不同方式的比较器比较岁数
private static class PersonComparator implements Comparator<Person> {
	public int compare(Person e1, Person e2) {
		// 年龄大则大
		return e1.getAge() - e2.getAge();
	}
}
	
private static class PersonComparator2 implements Comparator<Person> {
	public int compare(Person e1, Person e2) {
		// 年龄大反而小，类似按照剩余生命长短比较
		return e2.getAge() - e1.getAge();
	}
}

Comparable只有一种使用方式，即Person类实现compareTo方法

@Override
public int compareTo(Person e) {
//		if (age > e.age) return 1;
//		if (age < e.age) return -1;
//		return 0;
	return age - e.age;
}

// 测试时候，无参传递
Integer data[] = new Integer[] {
	7, 4, 9, 2, 5, 8, 11, 3, 12, 1
};
		
BinarySearchTree<Person> bst1 = new BinarySearchTree<>();
for (int i = 0; i < data.length; i++) {
	bst1.add(new Person(data[i]));
}