数据结构-二分搜索树篇

数据结构-二分搜索树篇

树结构本身是一种天然的组织结构

二叉树

和链表一样，动态数据结构

class Node{
	E e;
	Node left;
	Node right;
}

• 二叉树具有唯一 根节点

• 二叉树每个节点最多有两个孩子：左孩子，右孩子

• 叶子结点

• 二叉树每个节点最多有一个父节点

• 二叉树具有天然的递归结构

• 每个节点的左子树也是二叉树，每个节点的右子树页数二叉树

• 二叉树不一定是“满”的，一个节点也是二叉树，空也是二叉树

二分搜索树：也是二叉树

二分搜索树的每个节点的值：

• 大于其左子树的所有节点的值

• 小于其右子树的所有节点的值

• 每一个子树也是二叉树

• 存储的元素必须有可比较性

1. 定义二分搜索树节点

public class BST<E extends Comparable<E>> {
    private class Node{
        public E e;
        public Node left,right;
        public Node(E e){
            this.e = e;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BST(){
        root = null;
        size = 0;
    }

    public int size(){
        return size;
    }

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

2. 二分搜索操作

• 添加新元素

  不包含重复元素

  如果向包含重复元素的话，只需要定义：左子树小于等于节点；或者右子树大于等于节点

  PS：之前讲的数组和链表，可以有重复元素

  二分搜索树添加元素的非递归写法，和链表很像

  关注递归实现

//向二分搜索树中添加新的元素e
public void add(E e){
    if(root==null){
        root = new Node(e);
        size++;
    }else{
        add(root,e);
    }
}
//向以node为根的二分搜索树中插入元素E,递归算法
private void add(Node node,E e){
    if(e.equals(node.e)){
        return;
    }else if(e.compareTo(node.e)<0 && node.left==null){
        node.left = new Node(e);
        size++;
        return;
    }else if(e.compareTo(node.e)>0 && node.right==null){
        node.right = new Node(e);
        size++;
        return;
    }
    if(e.compareTo(node.e)<0){
        add(node.left,e);
    }else{
        add(node.right,e);
    }
}

• 改进递归终止条件

public void add(E e){
    root = add(root,e);
}
//返回插入新节点后二分搜索树的根(相同元素放不进来)
private Node add(Node node,E e ){
    if(node==null){
        size++;
        return new Node(e);
    }
    if(e.compareTo(node.e)<0){
        node.left = add(node.left,e);
    }else if(e.compareTo(node.e)>0) {
    node.right = add(node.right, e);

    }
    return node;
}

• 查询操作

//看二分搜索树中是否包含元素e
 public boolean contains(E e){
    return contains(root,e);
 }
 //以node为根的二分搜索树中是否包含元素额，递归算法
private boolean contains(Node node,E e){
     if(node==null){
         return false;
     }
     if(e.compareTo(node.e)==0){
         return true;
     }else if(e.compareTo(node.e)<0){
         return contains(node.left,e);
     }else{//(e.compareTo(node.e)>0)
         return contains(node.right,e);
     }
}

• 删除二分搜索树的最小元素

//寻找二分搜索树的最小元素
public E minimum() {
    if (size == 0) {
        throw new IllegalArgumentException("BST is empty");
    }
    return minimum(root).e;
}

//返回以node为根的二分搜索树的最小值所在的节点
private Node minimum(Node node) {
    if (node.left == null) {
        return node;
    }
    return minimum(node.left);
}
//从二分搜索树中删除最小值所在的节点，返回最小值
public E removeMin() {
    E ret = minimum();
    root = removeMin(root);
    return ret;
}
//删除掉以node为跟的二分搜索树中的最小节点
//返回删除节点后新的二分搜索树
private Node removeMin(Node node) {
    if (node.left == null) {
        Node rightNode = node.right;
        node.right = null;
        size--;
        return rightNode;
    }
    node.left = removeMin(node.left);
    return node;
}

• 删除二分搜索树的最大元素

//寻找二分搜索树的最大元素
public E maximum() {
    if (size == 0) {
        throw new IllegalArgumentException("BST is empty");
    }
    return maximum(root).e;
}

//返回以node为根的二分搜索树的最大值所在的节点
private Node maximum(Node node) {
    if (node.right == null) {
        return node;
    }
    return maximum(node.right);
}
//从二分搜索树中删除最小值所在的节点,返回最大值
public E removeMax(){
    E ret = maximum();
    root = removeMax(root);
    return ret;
}
//删除掉以node为跟的二分搜索树中的最大节点
//返回删除节点后新的二分搜索树
private Node removeMax(Node node){
    if(node.right==null){
        Node leftNode = node.left;
        node.left = null;
        size--;
        return leftNode;
    }
    node.right = removeMax(node.right);
    return node;
}

• 测试类

public static void main(String[] args) {
    BST<Integer> bst = new BST<>();
    Random random = new Random();
    int n=1000;
    for(int i=0;i<n;i++){
        bst.add(random.nextInt(10000));
    }

    ArrayList<Integer> nums = new ArrayList<>();
    while (!bst.isEmpty()){
        nums.add(bst.removeMin());
    }
    System.out.print(nums);
    for(int i=1;i<nums.size();i++){
        if(nums.get(i-1)>nums.get(i)){
            throw new IllegalArgumentException("Error");
        }
    }
    System.out.println("\nremoveMin test completed");
}

• 二分搜索树删除节点

//从二分搜索树中删除元素为e的节点
public void remove(E e) {
    root = remove(root, e);
}
//删除掉以node为根的二分搜索树中值为e的节点，递归算法
//返回删除节点后新的二分搜索树的根
private Node remove(Node node, E e) {
    if (node == null)
        return null;
    if (e.compareTo(node.e) < 0) {
        node.left = remove(node.left, e);
        return node;
    } else if (e.compareTo(node.e) > 0) {
        node.right = remove(node.right, e);
        return node;
    } else {  //e==node.e
        //待删除节点左子树为空的情况
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        //待删除节点右子树为空的情况
        if (node.right == null) {
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        //待删除节点左右子树均不为空
        //找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
        //用这个节点顶替待删除节点的位置
        Node successor = minimum(node.right);
        successor.right = removeMin(node.right);
        successor.left = node.left;
        node.left = node.right = null;
        return successor;
    }
}

3. 二分搜索树的遍历

• 前序遍历（深度优先遍历） 最自然，最常用的遍历方式
  
  遍历操作就是把所有节点都访问一遍

//二分搜索树的前序遍历
public void preOrder(){
    preOrder(root);
}
private void preOrder(Node node){
   /* if(node==null){
        return;
    }*/
    if(node!=null){
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }
}

测试类：

@Override
public String toString(){
    StringBuilder res = new StringBuilder();
    generateBSTString(root, 0, res);
    return res.toString();
}

// 生成以node为根节点，深度为depth的描述二叉树的字符串
private void generateBSTString(Node node, int depth, StringBuilder res){

    if(node == null){
        res.append(generateDepthString(depth) + "null\n");
        return;
    }

    res.append(generateDepthString(depth) + node.e + "\n");
    generateBSTString(node.left, depth + 1, res);
    generateBSTString(node.right, depth + 1, res);
}

private String generateDepthString(int depth){
    StringBuilder res = new StringBuilder();
    for(int i = 0 ; i < depth ; i ++)
        res.append("--");
    return res.toString();
}

public class Main {
    public static void main(String[] args) {
        BST<Integer> bst = new BST<>();
        int[] nums = {5,3,6,8,4,2};
        for(int num:nums){
            bst.add(num);
        }
        System.out.println(bst);
        bst.preOrder();
    }
}

• 中序遍历 ：遍历结果是顺序的
  

//二分搜索树的中序遍历
public void inOrder(){
    inOrder(root);
}
//中序遍历以node为根的二分搜索树，递归算法
private void inOrder(Node node){
    if(node==null){
        return;
    }else{
        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }
}

• 后序遍历
  

//二分搜索树的后续遍历
public void postOrder(){
    postOrder(root);
}
//后续遍历以node为根的二分搜索树，递归算法
private void postOrder(Node node){
    if(node==null){
        return;
    }else{
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.e);
    }
}

应用： 为二分搜索树释放内存

• 层序遍历（广度优先遍历）
  

//二分搜索树的层序遍历:广度优先遍历
public void levelOrder() {
    Queue<Node> queue = new LinkedList<>();
    queue.add(root);
    while (!queue.isEmpty()) {
        Node cur = queue.remove();
        System.out.println(cur.e);
        if (cur.left != null) {
            queue.add(cur.left);
        }
        if (cur.right != null) {
            queue.add(cur.right);
        }
    }
}

广度优先遍历的意义：

1. 更快的找到问题的解
2. 常用语算法设计中-最短路径
3. 图中的深度优先遍历和广度优先遍历

• 二分搜索树遍历的非递归实现

//前序遍历的非递归(深度优先遍历)
public void preOrderNR() {
    Stack<Node> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        Node cur = stack.pop();
        System.out.print(cur.e);
        if (cur.right != null) {
            stack.push(cur.right);
        }
        if (cur.left != null) {
            stack.push(cur.left);
        }
    }
}