java 树搜索_java实现二分搜索树

packagecom.wj;importjava.util.LinkedList;importjava.util.Queue;public class BST, Value>{private classNode {privateKey key;privateValue value;privateNode left, right;publicNode(Key key, Value value) {this.key =key;this.value =value;this.left = this.right = null;

}

}private Node root;//根节点

private intcount;publicBST() {

root= null;

count= 0;

}public voidinsert(Key key, Value value) {

root=insert(root, key, value);

}public booleancontainsKey(Key key) {returncontainsKey(root, key);

}publicValue get(Key key){

Node node=get(root, key);if (node != null) {returnnode.value;

}return null;

}private Node get(BST.Node node, Key key) {if (null == node) return null;if (key.compareTo(node.key) == 0) {returnnode;

}else if (key.compareTo(node.key) < 0) {returnget(node.left, key);

}else{returnget(node.right, key);

}

}//二分搜索树的前序遍历

public voidpreOrder(){

preOrder(root);

}//二分搜索树的中序遍历

public voidinOrder(){

inOrder(root);

}//二分搜索树的后序遍历

public voidpostOrder(){

postOrder(root);

}//层序遍历

public voidleaveOrder() {

Queue queue = new LinkedList<>();

queue.add(root);while (!queue.isEmpty()) {

Node node=queue.poll();

System.out.print(node.key+ " ");if (null !=node.left) {

queue.add(node.left);

}if (null !=node.right) {

queue.add(node.right);

}

}

}//查找最小节点key

publicKey findMin(){if (null == root) return null;returnfindMin(root).key;

}//查找最大节点key

publicKey findMax(){if (null == root) return null;returnfindMax(root).key;

}//删除最小值

public voiddeleteMin() {

root=deleteMin(root);

}//删除最大值

public voiddeleteMax() {

root=deleteMax(root);

}//删除任意值

public voidremove(Key key){

root=remove(root, key);

}public voidremove2(Key key){

root=remove2(root, key);

}private BST.Node remove(BST.Node node, Key key) {if (null == node) return null;if (key.compareTo(node.key) < 0) {

node.left=remove(node.left, key);returnnode;

}else if (key.compareTo(node.key) > 0) {

node.right=remove(node.right, key);returnnode;

}else{if (node.left == null) {

Node nodeRight=node.right;

node.right= null;--count;returnnodeRight;

}else if (node.right == null) {

Node nodeLeft=node.left;

node.left= null;--count;returnnodeLeft;

}else{

Node nodeRightMin=findMin(node.right);

nodeRightMin.right=deleteMin(node.right);

nodeRightMin.left=node.left;returnnodeRightMin;

}

}

}private BST.Node remove2(BST.Node node, Key key) {if (null == node || !containsKey(key)) returnnode;//获取key位置

Node currentNode =get(node, key);if (currentNode.left == null) {

currentNode=currentNode.right;

currentNode.right= null;--count;

}else if (currentNode.right == null) {

currentNode=currentNode.left;

currentNode.left= null;--count;

}else{

Node nodeRightMin=findMin(currentNode.right);

nodeRightMin.right=deleteMin(currentNode.right);

nodeRightMin.left=currentNode.left;

currentNode=nodeRightMin;

}returnnode;

}private Node deleteMax(BST.Node node) {if (node.right == null) {

Node leftNode=node.left;

node.left= null;--count;returnleftNode;

}

node.right=deleteMax(node.right);returnnode;

}private Node deleteMin(BST.Node node) {if (node.left == null) {

Node nodeRight=node.right;

node.right= null;--count;returnnodeRight;

}

node.left=deleteMin(node.left);returnnode;

}private Node findMax(BST.Node node) {if (node.right == null) returnnode;returnfindMax(node.right);

}private Node findMin(BST.Node node) {if (node.left == null) returnnode;returnfindMin(node.left);

}//清空二分搜索树//public void clear() {//System.out.println(root);//clear(root);

root = null;

count = 0;//}//

//private void clear(Node node) {//System.out.println(node);//node = null;//count = 0;//

//}

private void postOrder(BST.Node node) {if (null !=node) {

postOrder(node.left);

postOrder(node.right);

System.out.print(node.value+ " ");

}

}private void inOrder(BST.Node node) {if (null !=node) {

inOrder(node.left);

System.out.print(node.value+ " ");

inOrder(node.right);

}

}private void preOrder(BST.Node node) {if (null !=node) {

System.out.print(node.value+ " ");

preOrder(node.left);

preOrder(node.right);

}

}private boolean containsKey(BST.Node node, Key key) {if (null == node) return false;if (key.compareTo(node.key) == 0) {return true;

}else if (key.compareTo(node.key) < 0) {returncontainsKey(node.left, key);

}else{returncontainsKey(node.right, key);

}

}privateNode insert(Node node, Key key, Value value) {if (node == null) {++count;return newNode(key, value);

}else if (key.compareTo(node.key) == 0) {

node.value=value;

}else if (key.compareTo(node.key) < 0) {

node.left=insert(node.left, key, value);

}else{

node.right=insert(node.right, key, value);

}returnnode;

}public static void main(String[] args) throwsInterruptedException {//Map map = new HashMap<>();

BST bst = new BST<>();

bst.insert(1, 1);

bst.insert(2, 2);

bst.insert(16, 16);

bst.insert(13, 13);

bst.insert(49, 49);

bst.insert(38, 38);

bst.insert(3, 3);

bst.insert(3, 3);

bst.insert(61, 61);

bst.insert(17, 17);//bst.deleteMin();//bst.deleteMin();//bst.deleteMin();//bst.deleteMax();//bst.deleteMax();

bst.remove2(16);

System.out.println(bst.root== null);

System.out.println(bst.count);

System.out.println(bst.containsKey(3));

System.out.println(bst.get(3));

System.out.println("前驱遍历");

bst.preOrder();

System.out.println();

System.out.println("中驱遍历");

bst.inOrder();

System.out.println();

System.out.println("后驱遍历");

bst.postOrder();

System.out.println();

System.out.println("层序遍历");

bst.leaveOrder();

System.out.println();

System.out.println("最小值" +bst.findMin());

System.out.println("最大值" +bst.findMax());

}

}