java 二叉搜索树

Posted 小人物702

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java 二叉搜索树相关的知识,希望对你有一定的参考价值。

java二叉查找树实现:

二叉查找树,上图:比根节点小者在其左边,比根节点大者在其右边。

技术分享

抽象数据结构,上代码:

/**
 * 二叉查找树数据结构(非线程安全):
 * 范型类型须实现Comparable接口,用于比较操作
 */
public class BinarySearchTree<T extends Comparable<T>> { 
    private Node<T> root; // tree root
    private int count;    // tree element counts

    /**
     * 内部节点类
     */
    private static class Node<E>{
        E value; //元素对象
        Node<E> parent; //父节点
        Node<E> left; //左孩子节点
        Node<E> right; //右孩子节点
        public Node(E value, Node<E> parent, Node<E> left, Node<E> right) {
            this.value = value;
            this.parent = parent;
            this.left = left;
            this.right = right;
        }
    }
}

一些基本操作实现:

  • 插入(insert): 依次比较根元素,小者放左边,大者放右边:
/**
 * 插入元素
 * @param t 待插入元素
 * @return 插入成功返回true, 反之返回false
 */
public boolean insert(T t){
    if (root == null){ //若为空树
        root = new Node<T>(t, null, null, null);
        return true;
    }
    Node<T> newNode = new Node<T>(t, null, null, null);
    Node<T> pointer = root;
    while(true){
    if (newNode.value.compareTo(pointer.value) > 0){
        if (pointer.right == null){ //插入右边
        newNode.parent = pointer;
        pointer.right = newNode;
        count++;
        return true;
        } else{
        pointer = pointer.right;
        }
    } else if (newNode.value.compareTo(pointer.value) < 0){
        if (pointer.left == null){ //插入左边
        newNode.parent = pointer;
        pointer.left = newNode;
        count++;
        return true;
        } else{
        pointer = pointer.left;
        }
    } else { //相等了
        return false;
    }
    }
}
  • 查找(get):
/**
 * 查找元素
 * @param t 待查找元素
 * @return 对应元素或null
 */
public T get(T t) {
    Node<T> n = getN(t);
    return n == null? null : n.value;
}
    
/**
 * 查找节点
 * @param t 待查找元素
 * @return 元素对应节点或null
 */
private Node<T> getN(T t) {
    Node<T> cur = root;
    while (cur != null){
        if (cur.value.compareTo(t) < 0){ //右边子树找
            cur = cur.right;
        } else if(cur.value.compareTo(t) > 0){ //左边子树找
            cur = cur.left;
        } else{ //找到该节点
            break;
        }
    }
    return cur;
}

 

  • 查找最大,最小元素:
/**
 * 获取某节点为根的树的最小元素
 */
public T min(Node<T> n){
    Node<T> min = minN(n);
    return min == null ? null : min.value;
}
    
/**
 * 获取某节点为根的树的最小节点
 * @param n 树根节点
 * @return 该子树最小节点
 */
private Node<T> minN(Node<T> n){
    Node<T> min = n;
    while (min != null && min.left != null){
        min = min.left;
    }
    return min;
}
/**
 * 获取某节点为根的树的最大元素
 * @return 最大元素, 没有返回null
 */
public T max(Node<T> n){
    Node<T> max = maxN(n);
    return max == null ? null : max.value;
}
    
/**
 * 获取某节点为根的树的最大节点
 */
private Node<T> maxN(Node<T> n){
    Node<T> max = n;
    while (max != null && max.right != null){
        max = max.right;
    }
    return max;
}

 

  • 遍历树(中序遍历):
/**
 * 中序遍历
 */
public void leftRootRight(){
    printLRR(root);
}
    
/**
 * 中序遍历打印元素
 */
private void printLRR(Node<T> node) {
    if (node != null){
        printLRR(node.left);
        System.out.println(node.value);
        printLRR(node.right);
    }
}

 

  • 获取前驱(prev)元素:

        主要有两种情况:

           1.该节点左子树不为空:其前驱节点为其左子树的最大元素:

           技术分享

           2.该节点左子树为空: 其前驱节点为其祖先节点(递归),且该祖先节点的右孩子也为其祖先节点(就是一直往其parent找,出现左拐后的那个祖先节点):

技术分享

代码实现:

/**
 * 获取元素前驱(中序遍历)
 * @param t 指定元素
 * @return 元素前驱,没有返回null
 */
public T prev(T t){
    //先找到该元素
    Node<T> cur = getN(t);
    if (cur != null){
        return locatePrev(cur);
    }
    return null;
}
    
/**
 * 定位到前驱节点
 * @param cur 当前节点
 * @return 前驱节点,没有返回null
 */
private T locatePrev(Node<T> cur) {
    Node<T> prev = locatePrevN(cur); 
    return prev == null ? null : prev.value;
}
    
/**
 * 定位到前驱节点
 * @param cur 当前节点
 * @return 当前节点的前驱节点
 */
private Node<T> locatePrevN(Node<T> cur){
    if (cur != null){
        //1.如果该节点左子树不会空,则其前驱为其左子树的最大元素
        if (cur.left != null) return maxN(cur.left);
        //2.该节点左子树为空, 则其前驱为:其祖先节点(递归), 且该祖先节点的右孩子也是其祖先节点
        //  通俗的说,一直忘上找找到左拐后那个节点;
        Node<T> p = cur.parent;
        while(p != null && cur == p.left){
            cur = p;
            p = p.parent;
        }
        return p == null ? null: p;
    }
    return null;
}
  • 获取后继节点,也分两种情况:

      1.该节点右子树不为空,其后继节点为其右子树的最小元素:

        技术分享

       2.该节点右子树为空,其后继节点为其祖先节点(递归),且此祖先节点的左孩子也是该节点的祖先节点,就是说一直往上找其祖先节点,直到出现右拐后的那个祖先节点:

       技术分享

实现代码:

/**
 * 获取元素后继元素(中序遍历)
 * @param t 指定元素
 * @return 后继元素,没有返回null
 */
public T next(T t){
    //先找到该元素
    Node<T> cur = getN(t);
    if (cur != null){
        return locateNext(cur);
    }
    return null;
}
    
/**
 * 定位当前节点的后继元素
 * @param cur 当前节点
 * @return 其后继元素
 */
private T locateNext(Node<T> cur) {
    Node<T> next = locateNextN(cur);
    return next == null ? null : next.value;
}
    
/**
 * 定位到当前节点的后继节点
 * @param cur 当前节点
 * @return 当前节点的后继节点
 */
private Node<T> locateNextN(Node<T> cur) {
    if (cur == null) return null;
    //1.若其右子树不为空,那么其后继节点就是其右子树的最小元素
    if (cur.right != null) return minN(cur.right);
    //2.若为空,应该为其祖先节点(递归),且该祖先节点的左孩子也是其祖先节点
    //  通俗的说,一直忘上找,找到右拐后那个节点;
    Node<T> p = cur.parent;
    while (p != null && cur == p.right){
        cur = p;
        p = p.parent;
    }
    return p;
}

  • 删除(remove), 可分为三种情况:

      1.该节点为叶子节点,直接删除:

      技术分享

      2.该节点有一个孩子,将其孩子接上其父节点:

      技术分享    

      3.该节点有2个孩子,先删除其右子树的最小元素(该元素最多只会有一个孩子),将这个最小元素去替换要删除的节点:

      技术分享

实现代码:

/**
 * 移除某元素 
 * @param t 待删除元素
 * @return 删除成功返回true, 反之false
 */
public boolean remove(T t){
    //找到该节点
    Node<T> cur = getN(t);
    if (cur != null){
        if (doRemove(cur)){
            cur=null; count--;
            return true;
        }
    }
    return false;
}

/**
 * 执行删除操作
 */
private boolean doRemove(Node<T> cur) {
    //该节点是否为根
    boolean isRoot = cur == root;
    //1.该节点为叶子节点, 直接将其父节点对应(左或右)孩子置空
    if (cur.left == null && cur.right == null){
        if (isRoot) return true; //若树只有一个根节点
        if (cur == cur.parent.right) //该节点为父节点的右孩子
            cur.parent.right = null;
        else                    //该节点为父节点的左孩子
            cur.parent.left = null;
        return true;
    } else if(cur.left != null && cur.right != null){
        //2.该节点有2个孩子, 我们先找出一个替换节点(该节点的后继节点,后继节点没有则前驱节点)
        //找到其后继节点
        Node<T> replaceNode = locateNextN(cur);
        if (replaceNode == null) //若没有后继节点则用前驱节点
            replaceNode = locatePrevN(cur);
        doRemove(replaceNode);
        cur.value = replaceNode.value;
        return true;
    } else{ //3.该节点有1个孩子, 直接将其父节点对应(左或右)孩子接到其非空孩子
        Node<T> needLinkedNode = null;
        if (cur.left == null && cur.right != null){ //该节点有右孩子
            needLinkedNode = cur.right; 
        } else if(cur.left != null && cur.right == null){ //该节点有左孩子
            needLinkedNode = cur.left;
        }
        if(isRoot){ //若该节点为根
            root = needLinkedNode;
            return true;
        }
        if (cur == cur.parent.right)  //该节点为父节点右孩子
            cur.parent.right = needLinkedNode;
        else 
            cur.parent.left = needLinkedNode;
        return true;
    }
}

 


 

以上是关于java 二叉搜索树的主要内容,如果未能解决你的问题,请参考以下文章

Java实现:二叉搜索树(Binary Search Tree)

Java版高级数据结构二叉搜索树&红黑树

剑指 Offer 33. 二叉搜索树的后序遍历序列(java解题)

Java 剑指offer(36) 二叉搜索树与双向链表

二叉搜索树(Java实现)

Java 求解不同的二叉搜索树