数据结构 -- 二分搜索树

二分搜索树

1.若它的左子树不为空，则左子树上所有结点的值均小于等于根结点的值；

2.若它的右子树不为空，则右子树上所有结点的值均大于等于根结点的值；

3.它的左右子树均为二分查找树。

图片（注：百度搜索而来的图片）链接: link.

功能

前序遍历
中序遍历
后序遍历
层序遍历

删除最小元素
删除最大元素
删除任意元素

java代码实现

// An highlighted block
public class BSTree {
/**
* 节点类
*/
private class Node {
public Node left;
public Node right;
public int E;

public Node(int e) {
left = null;
right = null;
this.E = e;
}
}
private Node root;
private int size;

private int depth;

public BSTree() {
root = null;
this.size = 0;
}
/**
* 返回二分搜索树中元素的个数
*
* @return
*/
public int getSize() {
return this.size;
}

/**
* 返回二分搜索树中元素是否为空
*
* @return
*/
public boolean isEmpty() {
return this.size <= 0;
}

/**
* 添加元素
*
* @param e
*/
public void add(int e) {
root = _add(root, e);
}

private Node _add(Node node, int e) {
if (node == null) {
this.size++;
return new Node(e);
}
if (node.E > e) {
node.left = _add(node.left, e);
} else if (node.E < e) {
node.right = _add(node.right, e);
}
return node;
}

/**
* 是否包含元素e
*
* @param e
* @return
*/
public boolean contains(int e) {
return _contains(root, e);
}

private boolean _contains(Node node, int e) {
if (node == null) return false;
if (node.E == e) return true;
else if (node.E > e) return _contains(node.left, e);
else return _contains(node.right, e);
}

/**
* 前序遍历
*/
public void preOrder() {
_preOrder(root);
}

private void _preOrder(Node node) {
if (node == null) return;
System.out.println(node.E);
_preOrder(node.left);
_preOrder(node.right);
}

/**
* 后序遍历
*/
public void postOrder() {
_postOrder(root);
}

private void _postOrder(Node node) {
if (node == null) return;
_postOrder(node.left);
_postOrder(node.right);
System.out.println(node.E);
}

/**
* 中序遍历
*/
public void inOrder() {
_inOrder(root);
}

private void _inOrder(Node node) {
if (node == null) return;
_inOrder(node.left);
System.out.println(node.E);
_inOrder(node.right);
}

/**
* 层序遍历
*/
public void levelOrder() {
_levelOrder();
}

private void _levelOrder() {
if (root == null) {
return;
}
Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node n = queue.remove();
System.out.println(n.E);
if (n.left != null)
queue.add(n.left);
if (n.right != null)
queue.add(n.right);
}
}

/**
* 二分搜索树转为字符串
*
* @return
*/
public String toString() {
StringBuffer result = new StringBuffer();
_generateString(root, result, 0);
return result.toString();
}

/**
* 二分搜索树的最大深度
* @return
*/
public int depth() {
this.depth = 0;
_fall(root, 1);
return this.depth;
}
private void _fall(Node node, int depth) {

if (depth > this.depth && (node.left == null && node.right == null)) {
this.depth = depth;
}
if (node.right != null) {
_fall(node.right, depth + 1);
}

if (node.left != null) {
_fall(node.left, depth + 1);
}
}

private void _generateString(Node node, StringBuffer result, int depth) {
if (node == null) {
result.append(_generateDepthString(depth) + "\n");
return;
}
result.append(_generateDepthString(depth) + node.E + "\n");
_generateString(node.left, result, depth + 1);
_generateString(node.right, result, depth + 1);
}

private String _generateDepthString(int depth) {
StringBuffer depthString = new StringBuffer();
for (int i = 0; i < depth; i++) {
depthString.append("-");
}
return depthString.toString();
}
/**
* 删除元素e
*
* @param e
*/
public void remove(int e) {
root = _remove(root, e);
}

private Node _remove(Node node, int e) {
if (node == null) return null;
if (node.E > e) {
node.left = _remove(node.left, e);
return node;
} else if (node.E < e) {
node.right = _remove(node.right, e);
return node;
} else {
// 待删除节点左子树为空的情况
if (node.left == null) {
Node rightNode = node.right;
node.right = null;
this.size--;
return rightNode;
}
// 待删除节点右子树为空的情况
if (node.right == null) {
Node leftNode = node.left;
node.left = null;
this.size--;
return leftNode;
}

Node min_right = _minNode(node.right);
min_right.right = _removeMin(node.right);
min_right.left = node.left;
node.left = null;
node.right = null;
return min_right;
}

}

/**
* 最小元素
*
* @return
*/
public int min() {
return _minNode(root).E;
}

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

/**
* 最大元素
*
* @return
*/
public int max() {
return _maxNode(root).E;
}

private Node _maxNode(Node node) {
if (node.right == null) return node;
return _minNode(node.right);
}

/**
* 删除最小的元素
*
* @return
*/
public int removeMin() {
int min = min();
root = _removeMin(root);
return min;
}

private Node _removeMin(Node node) {
if (node == null) return null;
if (node.left == null) {
Node rightNode = node.right;
this.size--;
node.right = null;
return rightNode;
}
node.left = _removeMin(node.left);
return node;
}