1. 概述
- 二叉树规则
- 只能存在一个根节点。
- 每个节点最多只能存在两个子节点。
- 每个节点最多只能存在一个父亲节点。
- 二叉搜索树规则
- 拥有二叉树的规则。
- 大于其左子树所有节点的值。
- 小于其右子树所有节点的值。
- 存储的元素必须具有“可比较性”。
- 使用中序遍历,可以得到升序排列的数据。
2. 源码
public class BinarySearchTree<T extends Comparable<T>> {
private class Node {
private T data;
private Node left, right;
public Node(T data) {
this.data = data;
}
}
private Node root;
private int size;
public int getSize() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public void add(T data) {
root = add(root, data);
}
private Node add(Node node, T data) {
if (node == null) {
size++;
return new Node(data);
}
int compare = data.compareTo(node.data);
if (compare > 0) {
node.right = add(node.right, data);
} else if (compare < 0) {
node.left = add(node.left, data);
}
return node;
}
public boolean contains(T data) {
return contains(root, data);
}
private boolean contains(Node node, T data) {
if (node == null) {
return false;
}
int compare = data.compareTo(node.data);
if (compare == 0) {
return true;
} else if (compare > 0) {
return contains(node.right, data);
} else {
return contains(node.left, data);
}
}
public void preOrder() {
preOrder(root);
}
private void preOrder(Node node) {
if (node == null) {
return;
}
System.out.println(node.data);
preOrder(node.left);
preOrder(node.right);
}
public void preOrderNR() {
Stack<Node> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
Node cur = stack.pop();
System.out.println(cur.data);
if (cur.right != null) {
stack.push(cur.right);
}
if (cur.left != null) {
stack.push(cur.left);
}
}
}
public void levelOrder() {
LinkedList<Node> list = new LinkedList<>();
list.addLast(root);
while (!list.isEmpty()) {
Node cur = list.removeFirst();
System.out.println(cur.data);
if (cur.left != null) {
list.addLast(cur.left);
}
if (cur.right != null) {
list.addLast(cur.right);
}
}
}
public void inOrder() {
inOrder(root);
}
private void inOrder(Node node) {
if (node == null) {
return;
}
inOrder(node.left);
System.out.println(node.data);
inOrder(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.data);
}
public T getMinimum() {
if (isEmpty()) {
throw new IllegalArgumentException("The tree is empty!");
}
return getMinimum(root).data;
}
private Node getMinimum(Node node) {
if (node.left == null) {
return node;
}
return getMinimum(node.left);
}
public T getMaxmum() {
if (isEmpty()) {
throw new IllegalArgumentException("The tree is empty!");
}
return getMaxmum(root).data;
}
private Node getMaxmum(Node node) {
if (node.right == null) {
return node;
}
return getMaxmum(node.right);
}
public T removeMin() {
T result = getMinimum();
root = removeMin(root);
return result;
}
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 T removeMax() {
T result = getMaxmum();
root = removeMax(root);
return result;
}
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 void remove(T data) {
root = remove(root, data);
}
private Node remove(Node node, T data) {
if (node == null) {
return null;
}
int compare = data.compareTo(node.data);
if (compare > 0) {
node.right = remove(node.right, data);
return node;
} else if (compare < 0) {
node.left = remove(node.left, data);
return node;
} else {
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 = getMinimum(node.right);
successor.right = removeMin(node.right);
successor.left = node.left;
node.left = node.right = null;
return successor;
}
}
@Override
public String toString() {
StringBuilder result = new StringBuilder();
generatorToString(root, 0, result);
return result.toString();
}
private void generatorToString(Node node, int depth, StringBuilder result) {
if (node == null) {
result.append(generatorDepthString(depth) + "null\n");
return;
}
result.append(generatorDepthString(depth) + node.data + "\n");
generatorToString(node.left, depth + 1, result);
generatorToString(node.right, depth + 1, result);
}
private String generatorDepthString(int depth) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < depth; i++) {
result.append("--");
}
return result.toString();
}
public static void main(String[] args) {
BinarySearchTree<Integer> tree = new BinarySearchTree<>();
int[] nums = {10, 13, 15, 8, 7, 9};
for (int num : nums) {
tree.add(num);
}
System.out.println("==========Pre Order==============");
tree.preOrder();
System.out.println("==========Pre OrderNR==============");
tree.preOrderNR();
System.out.println("==========In Order==============");
tree.inOrder();
System.out.println("==========After Order==============");
tree.postOrder();
System.out.println("==========Pre OrderNR2==============");
tree.levelOrder();
System.out.println("==========Get minimum Tree Node==============");
System.out.println(tree.getMinimum());
System.out.println("==========Remove minimum Tree Node Before==============");
System.out.println(tree.removeMin());
System.out.println("==========Remove minimum Tree Node After==============");
tree.inOrder();
System.out.println("==========Remove maxmum Tree Node Before==============");
System.out.println(tree.removeMax());
System.out.println("==========Remove maxmum Tree Node After==============");
tree.inOrder();
}
}