提出问题

在n个动态的整数中搜索某个整数，你会选择什么数据结构？

假设使用动态数组，则从第0个位置进行遍历搜索，平均时间复杂度为:O(n)

假如维护一个有序的动态数组，使用二分搜索，最坏时间复杂度为:O(logn),但是添加和删除操作的平均时间复杂度为O(n)

如果使用二叉搜索树，无论添加、删除、搜索的最坏时间复杂度可以为:O(logn)。

二叉搜索树(Binary Search Tree)

二叉搜索树是二叉树的一种，又可称为:二叉查找树或二叉排序树

特点:

任一节点的值都大于其左子树所有节点的值
任一节点的值都小于其右子树所有节点的值
它的左右子树也都是二叉搜索树
二叉搜索树可以大大提高搜索数据的效率
二叉搜索树存储的元素必须具备可比较性

a.例如int、double等

b.如果是自定义类型，需要指定比较方式

c.不允许为null

实现二叉树的接口设计

// 元素的数量
public int size() 
// 是否为空
public boolean isEmpty()
// 清空所有元素
public void clear()
// 添加元素
public void add(E element)
// 移除元素
public void remove(E element)
// 判断是否包含某元素
public boolean contains(E element)

创建节点类

节点中应该包含:

存放的元素
左节点
右节点
父节点

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;

    }

}

添加节点

例如对这棵树进行添加12和1的过程

步骤:

找到根节点7,发现12比7大，找到右节点9
12比9大,找到右节点11
12比11大,发现右节点为空
创建新的节点，元素为12，父节点是11,成为11的右子树

实现:

之前说过二叉搜索树中的元素必须具有可比较性，可以看到在添加时会有一次比较的操作compare(E e1, E e2),例子中Integer类型本身具有可比较性，如果是自定义类型呢？

元素比较方案的设计

假如现在加入二叉搜索树的元素类型为Person,比较规则为比较年龄，年龄大的元素为大

通过`Comparable`接口

创建一个接口，其中定义比较方法

public interface Comparable<E> {

    int compareTo(E e); 

}

那么只需让二叉搜索树的泛型来实现这个接口的方法即可，即:

public class BinarySearchTree<E extends Comparable<E>>

那么在compare(E e1, E e2)方法中让元素类来比较即可

private int compare(E e1, E e2) {

     return e1.compareTo(e2);

}

但是这个方案的弊端在于比较的方法写死在元素类中，并不灵活。

外界传入比较器Comparator

public interface Comparator<E> {

int compare(E e1, E e2);

}

二叉搜索树中添加Comparator 属性，由外界传入比较器

public class BinarySearchTree<E> {

    private int size;

    private Node<E> root;

    private Comparator<E> comparator;


    public BinarySearchTree(Comparator<E> comparator) {

        this.comparator = comparator;

    }

    
}

那么在外部便可以自己定义比较规则

private static class PersonComparator1 implements Comparator<Person> {

    *@Override*

    public int compare(Person e1, Person e2) {

        // **TODO** Auto-generated method stub

        return e1.getAge() - e2.getAge();

    }

}

总结

第二种方案看似灵活了，但是会强制外部一定要传入一个比较器，这样也不是很合理，那么比较好得方案便是对这两种方案进行结合，不用强制外部一定传入比较器，那么内部判断，如果外部有比较器就使用比较器，如果没有就强制元素实现Comparable接口

private int compare(E e1, E e2) {

    if (comparator != null) {

        return comparator.compare(e1, e2);

       } else {

        // 不在类的地方去强制，在这里强制

        return ((Comparable<E>)e1).compareTo(e2);

      }

}

二叉树的遍历

遍历是数据结构中常见的操作，即把所有的元素都访问一遍
线性数据结构的遍历分为:正序遍历和逆序遍历
二叉树的常见遍历方式有四种:

1.前序遍历(Preorder Traversal)

2.中序遍历(Inorder Traversal)

3.后序遍历(Postorder Traversal)

4.层序遍历(Level Order Traversal)