二叉搜索树(BinarySearchTree)
一棵二叉搜索树是以一颗二叉树来组织的。对于它的每一个节点Node,其左子树的关键字最大不超过Node.key,其右子树中的关键字最小不低于Node.key,下面是它的Java实现:
/**
* Created by wukn on 2017/11/7.
*/
public class BinarySearchTree<Key extends Comparable<Key>, Value> {
private Node rootNode;
private class Node {
private Key key;
private Value data;
private Node parent;
private Node leftChild;
private Node rightChild;
public Node(Key key, Value data) {
this.key = key;
this.data = data;
}
}
/**
* 添加节点
* @param node
* @return
*/
public boolean put(Node node) {
if(node == null) {
return false;
}
if(rootNode == null) {
rootNode = node;
return true;
}
Node findNode = rootNode;
Node parentNode = rootNode;
while(findNode != null) {
parentNode = findNode;
int cmp = findNode.key.compareTo(node.key);
if(cmp > 0) {
findNode = findNode.leftChild;
}else if(cmp < 0) {
findNode = findNode.rightChild;
}else if(cmp == 0) {
findNode.data = node.data;
return true;
}
}
if(parentNode.key.compareTo(node.key) > 0) {
parentNode.leftChild = node;
}else {
parentNode.rightChild = node;
}
node.parent = parentNode;
return true;
}
public Node search(Key key) {
return search(rootNode, key);
}
private Node search(Node node, Key key) {
if(node == null || node.key == key) {
return node;
}
if(node.key.compareTo(key) < 0) {
return search(node.rightChild, key);
}else {
return search(node.leftChild, key);
}
}
public Node min() {
return min(rootNode);
}
private Node min(Node node) {
while(node.leftChild != null) {
node = node.leftChild;
}
return node;
}
public Node max() {
return max(rootNode);
}
private Node max(Node node) {
while(node.rightChild != null) {
node = node.rightChild;
}
return node;
}
private void transplant(Node u, Node v) {
if(u.parent == null) {
rootNode = v;
}else if(u == u.parent.leftChild) {
u.parent.leftChild = v;
}else {
u.parent.rightChild = v;
}
if(v != null) {
v.parent = u.parent;
}
}
public boolean delete(Node node) {
if(node.leftChild == null) {
transplant(node, node.rightChild);
}else if(node.rightChild == null) {
transplant(node, node.leftChild);
}else {
Node y = min(node.rightChild);
if(y.parent != node) {
transplant(y, y.rightChild);
y.rightChild = node.rightChild;
y.rightChild.parent = y;
}
transplant(node, y);
y.leftChild = node.leftChild;
y.leftChild.parent = y;
}
return true;
}
public static void main(String[] args) {
BinarySearchTree<Integer, String> binarySearchTree = new BinarySearchTree<>();
binarySearchTree.put(binarySearchTree.new Node(1,"CvShrimp"));
binarySearchTree.put(binarySearchTree.new Node(2,"Zero"));
binarySearchTree.put(binarySearchTree.new Node(3,"Lelouch"));
binarySearchTree.put(binarySearchTree.new Node(3,"Avalon"));
binarySearchTree.put(binarySearchTree.new Node(6,"Adol"));
BinarySearchTree.Node node = binarySearchTree.search(6);
binarySearchTree.delete(node);
System.out.println(binarySearchTree.max().data);
}
}