每日一省之——使用递归法实现二叉查找树（BST），API齐全

本来国庆该出去转转的，可是在杭州朋友不多。现在的公司规模又太大，没上一家公司凝聚力强，想找同事出来聚聚，后来发现有心无力。所以国庆还是敲代码吧。不过此刻刚写完二叉树，发现已到凌晨2点，注释也不全。改天再完善吧。之所以有勇气贴出来，是觉得对得起自己的这番苦心。并且，实现二叉搜索树一般需要实现的API我也尽可能补全了。有几个重要方法的注释其实我写的也蛮详细的，估计看方法注释也就能懂了，用不着我过多赘述。本篇虽然名为递归法实现BST，实际上非递归法的前序，中序，后序遍历也都收入其中了。若本实现有什么不对的地方，欢迎大家批评指正。

import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;
import java.util.Stack;

public class BST<K extends Comparable<K>, V> {

private Node root;

/**
* 该私有内部类用于构造二叉查找树的节点
*
* @author lhever
*/
private class Node {
private K key;
private V value;
private Node left;
private Node right;
private int N;

public Node(K key, V value, int n) {
this.key = key;
this.value = value;
this.N = n;
}

/**
* eclipse自动生成
*/
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + getOuterType().hashCode();
result = prime * result + N;
result = prime * result + ((key == null) ? 0 : key.hashCode());
result = prime * result + ((left == null) ? 0 : left.hashCode());
result = prime * result + ((right == null) ? 0 : right.hashCode());
result = prime * result + ((value == null) ? 0 : value.hashCode());
return result;
}

/**
* eclipse自动生成，在这里的二叉树实现下，用于比较两个节点是否相等是完全可以的，why?大家自己思考咯
*/
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Node other = (Node) obj;
if (!getOuterType().equals(other.getOuterType()))
return false;
if (N != other.N)
return false;
if (key == null) {
if (other.key != null)
return false;
} else if (!key.equals(other.key))
return false;
if (left == null) {
if (other.left != null)
return false;
} else if (!left.equals(other.left))
return false;
if (right == null) {
if (other.right != null)
return false;
} else if (!right.equals(other.right))
return false;
if (value == null) {
if (other.value != null)
return false;
} else if (!value.equals(other.value))
return false;
return true;
}

private BST getOuterType() {
return BST.this;
}

}

public BST() {
}

private int size(Node node) {
if (node == null) {
return 0;
} else {
return node.N;
}

}

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

public int size() {
return size(root);
}

/**
* 查找方法， 返回与置顶键关联的值
*
* @param key
* @return
*/
public V get(K key) {
return get(root, key);
}

private V get(Node node, K key) {
if (node == null) {
return null;
}
int cmp = key.compareTo(node.key);
if (cmp < 0) {
return get(node.left, key);
} else if (cmp > 0) {
return get(node.right, key);
} else {
return node.value;
}

}

/**
* 判断是否包含key指定的键
* @param key
* @return
*/
public boolean contains(K key) {
if (key == null) {
throw new NullPointerException("参数不能为null");
}
return get(key) != null;
}

/**
* 插入键值对
* @param key
* @param value
*/
public void put(K key, V value) {
if (key == null) {
throw new NullPointerException("参数不能为null");
}
if (value == null) {
delete(key);
return;
}

root = put(root, key, value);
assert check();

}

/**
* 将指定的键值对插入二叉树中。
*
* @param node
* @param key
* @param value
* @return
*/
private Node put(Node node, K key, V value) {
if (node == null) {
return new Node(key, value, 1);
}
int cmp = key.compareTo(node.key);
if (cmp < 0) {
node.left = put(node.left, key, value);
} else if (cmp > 0) {
node.right = put(node.right, key, value);
} else {
node.value = value;
}
node.N = size(node.left) + 1 + size(node.right);
return node;
}

/**
* 查找最小的键
* @return
*/
public K min() {
if (isEmpty()) {
throw new NoSuchElementException("二叉搜索树为空");
}
return min(root).key;

}

private Node min(Node node) {
if (node.left == null) {
return node;
} else {
return min(node.left);
}
}

/**
* 查找最大的键
* @return
*/
public K max() {
if (isEmpty()) {
throw new NoSuchElementException("二叉搜索树为空");
}
return max(root).key;
}

private Node max(Node node) {
if (node.right == null) {
return node;
} else {
return max(node.right);
}
}

public void deleteMin() {
if (isEmpty()) {
throw new NoSuchElementException("二叉搜索树为空, 删除失败");
}
root = deleteMin(root);
assert check();
}

/**
* 删除以参数node为根节点的二叉搜索树的最小节点，并返回删除最小节点后的二叉搜索树。
*
* @param node
* @return
*/
private Node deleteMin(Node node) {
/*
* 左节点为空，则树中最小节点就是根节点，删除后的二叉树由根节点的右子树构成
*/
if (node.left == null) {
return node.right;
}
node.left = deleteMin(node.left);
node.N = size(node.left) + 1 + size(node.right);
return node;
}

public void deleteMax() {
if (isEmpty()) {
throw new NoSuchElementException("二叉搜索树为空, 删除失败");
}
root = deleteMax(root);
assert check();
}

/**
* 删除以参数node为根节点的二叉搜索树的最大节点，并返回删除最大节点后的二叉搜索树。
*
* @param node
* @return
*/
private Node deleteMax(Node node) {
/*
* 又节点为空，则树中最大节点就是根节点，删除后的二叉树由根节点的左子树构成
*/
if (node.right == null) {
return node.left;
}
node.right = deleteMax(node.right);
node.N = size(node.left) + 1 + size(node.right);
return node;
}

public void delete(K key) {
if (key == null) {
throw new NullPointerException("参数不能为null");
}

root = delete(root, key);
assert check();
}

private Node delete(Node node, K key) {
if (node == null) {
return null;
}
int cmp = key.compareTo(node.key);
if (cmp < 0) {
node.left = delete(node.left, key);
} else if (cmp > 0) {
node.right = delete(node.right, key);
} else {

if (node.left == null) {
return node.right;
}
;
if (node.right == null) {
return node.left;
}
Node temp = node;
node = min(temp.right);
node.right = deleteMin(temp.right);
node.left = temp.left;
}

node.N = size(node.left) + 1 + size(node.right);
return node;

}

/**
* 向下取整，这个方法的执行过程可以这样来理解（具体实现不是这样的，此处帮助理解）：二叉搜索树中的键值对是键有序的， 该方法首先将树中的所有节点
* 按照键的大小排序，排好序之后，假设参数指定的key代表一个节点（该节点在树中可能存在也可能不存在），所以我们也按排序规则将参数key指定的键插入
* 之前已经排号序的序列中， 如果key的确是树中的某个节点，则这个虚拟的key与真实的某个节点重合。如果key不存在于树中，则这个虚拟的key会按大小
* 处于排好序的序列中的 某个位置。该方法返回的是小于或者等于参数指定的key，并且真实存在于树中的那个key。所以，该方法的名称与大多数编程语言中
* 提供的整数向下取整的方法语义有诸多相似之处
* @param key
* @return
*/
public K floor(K key) {
if (key == null) {
throw new NullPointerException("参数不能为null");
}
if (isEmpty()) {
throw new NoSuchElementException("二叉搜索树为空");
}
Node x = floor(root, key);
if (x == null) {
return null;
} else {
return x.key;
}
}

private Node floor(Node node, K key) {
if (node == null)
return null;
int cmp = key.compareTo(node.key);
if (cmp == 0) {
return node;
}
if (cmp < 0) {
return floor(node.left, key);
}
Node temp = floor(node.right, key);
if (temp != null) {
return temp;
} else {
return node;
}
}

/**
* 向上取整。参照floor()方法的注释来理解
* @param key
* @return
*/
public K ceiling(K key) {
if (key == null) {
throw new NullPointerException("参数不能为null");
}
if (isEmpty()) {
throw new NoSuchElementException("二叉搜索树为空");
}
Node node = ceiling(root, key);
if (node == null) {
return null;
} else {
return node.key;
}
}

private Node ceiling(Node node, K key) {
if (node == null) {
return null;
}
int cmp = key.compareTo(node.key);
if (cmp == 0) {
return node;
}
if (cmp < 0) {
Node temp = ceiling(node.left, key);
if (temp != null) {
return temp;
} else {
return node;
}
}
return ceiling(node.right, key);
}

/*
* 二叉搜索树中的键值对是键有序的， 该方法返回将树中的所有节点按键的大小排序后， 键的大小排在第k位的节点.
* 并且: 0 <= k < size() -1
*/
public K select(int k) {
if (k < 0 || k >= size()) {
throw new IllegalArgumentException();
}
Node x = select(root, k);
return x.key;
}

/**
* 二叉搜索树中的键值对是键有序的， 该方法返回将树中的所有节点按键的大小排序后， 键的大小排在第k位的节点.
*
* @param x
* @param k
* @return
*/
private Node select(Node node, int k) {
if (node == null) {
return null;
}
int t = size(node.left);
/*
* 如果当前节点的左子树的大小比k大， 则键的排名为k的节点一定在左子树中
*/
if (t > k) {
return select(node.left, k);
}
/*
* 如果当前节点的左子树大小比k小，则排名为k的节点一定在右子树中，并且在右子树中的排名为k-t-1。
* 因为k指代的是在整棵树中的排名，排名从0开始。左子树中键最大的节点排名为t-1(左子树的大小为t)，当前节点排为t,
* 所以左子树加当前节点的节点总数是t+1， 排名为k的节点一定是在右子树中排名为k-(t+1)(也即 k-t-1)的节点,该节点其
* 实就是在右子树中大小为k-t-1的子树的根节点
*/
else if (t < k) {
return select(node.right, k - t - 1);
}
/*
* 因为k指代的是在整棵树中的排名，排名从0开始。左子树中键最大的节点排名为t-1(左子树的大小为t)，
* 当前节点比左子树中的任何节点都大，所以恰好排名为t。所以此处返回当前节点
*/
else {
return node;
}
}

public int rank(K key) {
if (key == null) {
throw new NullPointerException("参数不能为null");
}
return rank(key, root);
}

/**
* 二叉搜索树中的键值对是键有序的， 该方法首先将树中的所有节点按键的大小排序， 然后返回参数指定的键在排好序的节点序列中的序号。
* 若键不存在于树种，一律返回0
*
* @param key
* @param node
* @return
*/
private int rank(K key, Node node) {
if (node == null) {
return 0;
}
int cmp = key.compareTo(node.key);
if (cmp < 0) {
return rank(key, node.left);
} else if (cmp > 0) {
return 1 + size(node.left) + rank(key, node.right);
} else {
return size(node.left);
}
}

public Iterable<K> keys() {
return keys(min(), max());
}

/**
* 返回键的大小在low和high两个参数指定的范围内的键
* @param low
* @param high
* @return
*/
public Iterable<K> keys(K low, K high) {
if (low == null) {
throw new NullPointerException("low为空null");
}
if (high == null) {
throw new NullPointerException("high为null");
}

Queue<K> queue = new LinkedList<K>();
keys(root, queue, low, high);
return queue;
}

private void keys(Node node, Queue<K> queue, K low, K high) {
if (node == null) {
return;
}
int cmplo = low.compareTo(node.key);
int cmphi = high.compareTo(node.key);
if (cmplo < 0) {
keys(node.left, queue, low, high);
}
if (cmplo <= 0 && cmphi >= 0) {
queue.add(node.key);
}
if (cmphi > 0) {
keys(node.right, queue, low, high);
}
}

/**
* 返回大小在low和high两个参数指定的范围内的键的总数
* @param low
* @param high
* @return
*/
public int size(K low, K high) {
if (low == null) {
throw new NullPointerException("low为null");
}
if (high == null) {
throw new NullPointerException("high为null");
}

if (low.compareTo(high) > 0) {
return 0;
}
if (contains(high)) {
return rank(high) - rank(low) + 1;
} else {
return rank(high) - rank(low);
}
}

/**
* 返回二叉搜索树的高度
*
* @return
*/
public int height() {
return height(root);
}

private int height(Node x) {
if (x == null)
return -1;
return 1 + Math.max(height(x.left), height(x.right));
}

/**
* 返回树中所有节点的迭代器，遍历所有节点的方式是层序遍历。
*
* @return
*/
public Iterable<K> levelOrder() {
Queue<K> keys = new LinkedList<K>();
Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node node = queue.remove();
if (node == null) {
continue;
}
keys.add(node.key);
queue.add(node.left);
queue.add(node.right);
}
return keys;
}

private boolean check() {
if (!isBST()) {
System.out.println("经检查不符合二叉树定义");
}
if (!checkSizeConsistent()) {
System.out.println("size检查异常");
}
if (!checkRankConsistent()) {
System.out.println("秩检查异常");
}
return isBST() && checkSizeConsistent() && checkRankConsistent();
}

/**
* 判断是否满足二叉查找树的定义（左子树的节点比当前节点都小， 右子树中的节点比当前节点都大）
*
* @return
*/
private boolean isBST() {
return isBST(root, null, null);
}

private boolean isBST(Node node, K min, K max) {
if (node == null) {
return true;
}
// 不可能比最小节点小
if (min != null && node.key.compareTo(min) <= 0) {
return false;
}
// 不可能比最大节点大
if (max != null && node.key.compareTo(max) >= 0) {
return false;
}

/*
* 切分后比较
*/
return isBST(node.left, min, node.key) && isBST(node.right, node.key, max);
}

private boolean checkSizeConsistent() {
return checkSizeConsistent(root);
}

/**
* 判断任意节点大小是不是等于： （左节点大小 + 1 + 右节点大小）
*
* @param node
* @return
*/
private boolean checkSizeConsistent(Node node) {
if (node == null) {
return true;
}
if (node.N != size(node.left) + size(node.right) + 1) {
return false;
}
return checkSizeConsistent(node.left) && checkSizeConsistent(node.right);
}

/**
* 检查各个节点的键的实际排名（秩）是否与我们通过方法计算出来的一致
*
* @return
*/
private boolean checkRankConsistent() {
for (int i = 0; i < size(); i++)
if (i != rank(select(i))) {
return false;
}
for (K key : keys()) {
if (key.compareTo(select(rank(key))) != 0)
return false;
}
return true;
}

/**
* 打印出节点的内容和值
*
* @param node
*/
public void visit(Node node) {
StringBuffer buff = new StringBuffer();
if (node != null) {
buff.append(" " + node.key + "[");
String left = node.left != null ? node.left.key + "" : "null";
String right = node.right != null ? node.right.key + "" : "null";
buff.append(left)
.append(" : ")
.append(right)
.append("] ");
}
System.out.print(buff.toString());
}

/** 递归实现前序遍历 */
private void recursivePreorder(Node node) {
if (node != null) {
visit(node);
recursivePreorder(node.left);
recursivePreorder(node.right);
}
}

public void recursivePreorder() {
recursivePreorder(root);
}

/** 递归实现中序遍历 */
private void recursiveInorder(Node node) {
if (node != null) {
recursiveInorder(node.left);
visit(node);
recursiveInorder(node.right);
}
}

public void recursiveInorder() {
recursiveInorder(root);
}

/** 递归实现后序遍历 */
private void recursivePostorder(Node node) {
if (node != null) {
recursivePostorder(node.left);
recursivePostorder(node.right);
visit(node);
}
}

public void recursivePostorder() {
recursivePostorder(root);
}

/** 非递归实现前序遍历 */
private void preorder(Node node) {
Stack<Node> stack = new Stack<Node>();
if (node != null) {
stack.push(node);
while (!stack.empty()) {
node = stack.pop();
visit(node);
if (node.right != null) {
stack.push(node.right);
}
if (node.left != null) {
stack.push(node.left);
}
}
}
}

public void preorder() {
preorder(root);
}

/**
* 非递归实现后序遍历
*
* 后序遍历的非递归算法是三种顺序中最复杂的，原因在于，后序遍历是先访问左、右子树,再访问根节点，
* 而在非递归算法中，利用栈回退到时，并不知道是从左子树回退到根节点，还是从右子树回退到根节点，
* 如果从左子树回退到根节点，取出的根节点应该放回去，然后去访问右子树，而如果从右子树回退到根节点，此时的确轮到访问
* 根节点了。这个过程相比前序和后序，必须得在压栈时添加信息（此处的实现利用参数q记录已经访问过的节点，如果右节点已经访问过
* ， 则可以访问栈中弹出的根节点，如果右节点还没有访问过，则再次将弹出的根节点压回栈中，转而访问右节点，待访问右节点结束再弹出根节点进行访问），
* 以便在退栈时可以知道是从左子树返回， 还是从右子树返回进而决定下一步的操作。
**/
private void postorder(Node p) {
Node q = p;
Stack<Node> stack = new Stack<Node>();
while (p != null) {
// 左子树入栈
for (; p.left != null; p = p.left) {
stack.push(p);
}
// 当前节点无右子或右子已经输出
while (p != null && (p.right == null || p.right == q)) {
visit(p);
q = p;// 记录上一个已输出节点
if (stack.empty()) {
return;
}
p = stack.pop();
}
// 处理右子
stack.push(p);
p = p.right;
}
}

public void postorder() {
postorder(root);
}

/** 非递归实现中序遍历 */
private void inorder(Node p) {
Stack<Node> stack = new Stack<Node>();
while (p != null) {
while (p != null) {
if (p.right != null) {
stack.push(p.right);// 当前节点右子入栈
}
stack.push(p);// 当前节点入栈
p = p.left;
}
p = stack.pop();
while (!stack.empty() && p.right == null) {
visit(p);
p = stack.pop();
}
visit(p);
if (!stack.empty()) {
p = stack.pop();

} else {
p = null;
}
}
}

public void inorder() {
inorder(root);
}

public static void main(String[] args) {
BST<String, Integer> st = new BST<String, Integer>();
st.put("China", 1);
st.put("America", 2);
st.put("Japan", 100);
st.put("Russian", 3);
st.put("Poland", 8);
st.put("India", 99);

for (String s : st.levelOrder()) {
System.out.println(s + " ---> " + st.get(s));
}

for (String s : st.keys()) {
System.out.println(s + " " + st.get(s));
}

/**
*                            H
*                           /  \
*                          /    \
*                         D      L
*                        /  \   / \
*                       /    \ I  X
*                      B      G
*                     / \    / \
*                    A   C  F  无
*                          / \
*                         E   无
*/
BST<String, String> st1 = new BST<String, String>();
st1.put("H", "H0");
st1.put("D", "D0");
st1.put("B", "B0");
st1.put("G", "G0");
st1.put("A", "A0");
st1.put("C", "C0");
st1.put("F", "F0");
st1.put("E", "E0");
st1.put("L", "L0");
st1.put("I", "I0");
st1.put("X", "X0");

st1.recursivePreorder();
System.out.println();
st1.recursiveInorder();
System.out.println();
st1.recursivePostorder();
System.out.println();
System.out.println("--------------------------------------------------------------------");
st1.preorder();
System.out.println();
st1.postorder();
System.out.println();
st1.inorder();

}

}