package wck.sort;/**
* Created on 18/9/10.
*/
import java.util.ArrayList;
import java.util.Queue;
/**
* @program: demo
* @description: 二分搜索樹
* @author: wck
* @create: 2018-09-10 12:50
**/
public class BST {
/**
* 節點類
* @param <Key>
* @param <Value>
*/
private class Node<Key extends Comparable<Key>,Value> {
//鍵值對的key
private Key key;
//鍵值對的value
private Value value;
//當前節點的左右節點
private Node right,left;
public Node(Node node){
this.key = (Key) node.key;
this.value = (Value) node.value;
this.left = node.left;
this.right = node.right;
}
public Node (Key key,Value value){
this.key =key;
this.value=value;
right = left = null;
}
//根節點
private Node root;
//記錄元素個數
private int count;
//默認構造函數
public Node (){
this.root =null;
count = 0;
}
/**
* 添加元素
* @param key
* @param value
*/
public void insert(Key key,Value value){
root = insert(root,key,value);
}
/**
* 遞歸的條件爲:否則會判斷當前新加節點
* 是不是比左子節點小,滿足繼續走左分支,如果當前加入節點比右子節點大則加入右分支;繼續遞歸
* @param node
* @param key
* @param value
* @return
*/
Node insert(Node node,Key key,Value value){
//當前節點爲空,新建節點
if(node == null){
count++;
return new Node(key,value);
}
if(node.key == key)
node.value = value;
else if(key.compareTo((Key) node.key)<0)
insert(node.left, key, value);
else
insert(node.right,key,value);
return node;
};
//是夠包含當前元素
boolean contain(Key key){
return contain(root,key);
}
boolean contain(Node node,Key key){
if(node == null){
return false;
}
if(node.key == key)
return true;
else if(key.compareTo((Key) node.key) < 0)
return contain(node.left,key);
else
return contain(node.right,key);
}
//查詢元素
Value search(Key key){
return search(root,key);
}
Value search(Node node,Key key){
if(node == null)
return null;
if(key.compareTo((Key) node.key) == 0)
return (Value) node.value;
else if (key.compareTo((Key) node.key) < 0)
return search(node.left,key);
else
return search(node.right,key);
}
/** 前序遍歷,中序遍歷,後序遍歷都是'深度優先'遍歷;也就是遍歷到最底部後再返回繼續
* //前序遍歷 ---依次遍歷
* @param node
*/
void preOder(Node node){
if(node != null){
System.out.println(node.key);
preOder(node.left);
preOder(node.right);
}
}
//中序遍歷 ---從小到大
void inOrder(Node node){
if(node != null){
inOrder(node.left);
System.out.println(node.key);
inOrder(right);
}
}
//後序遍歷 ---將左右子數遍歷完後,才釋放自身;釋放整個樹
void postOrder(Node node){
if(node != null){
postOrder(node.left);
postOrder(right);
System.out.println(node.key);
}
}
//釋放整個樹實現--
void destroy(Node node){
destroy(node.left);
destroy(right);
node = null; //help GC
count--;
}
//廣度優先級遍歷(層級遍歷)
void levelOrder(){
Queue<Node> queue = (Queue) new ArrayList<Node>();
queue.add(root);
while(!queue.isEmpty()){
//刪除操作返回之前的元素
Node remove = queue.remove();
System.out.println(remove.key);
if(remove.left != null)
queue.add(remove.left );
if(remove.right != null)
queue.add(remove.right );
}
}
// 返回以node爲根的二分搜索樹的最小鍵值所在的節點
private Node minimum(Node node){
if( node.left == null )
return node;
return minimum(node.left);
}
// 刪除掉以node爲根的二分搜索樹中的最小節點
// 返回刪除節點後新的二分搜索樹的根
private Node removeMin(Node node){
if( node.left == null ){
Node rightNode = node.right;
node.right = null;
count --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
// 刪除掉以node爲根的二分搜索樹中的最大節點
// 返回刪除節點後新的二分搜索樹的根
private Node removeMax(Node node){
if( node.right == null ){
Node leftNode = node.left;
node.left = null;
count --;
return leftNode;
}
node.right = removeMax(node.right);
return node;
}
//二叉樹刪除元素
Node remove(Key key){
Node remove = remove(root, key);
return remove;
}
Node remove(Node node,Key key){
//要是特麼的爲空纔則返回,否則要是以下條件:1,2都不會返回
if(node == null)
return null;
//1:比左子節點小
if(key.compareTo((Key) node.left) <0){
node.left = remove(node.left,key);
return node;
} else if(key.compareTo((Key) node.left) <0){
node.left = remove(node.left,key);
return node;
//即 key == node.key
}else{
//左樹爲空
if(node.left == null){
Node rightNode = node.right;
node.right = null;
count =count -1; //自減一
return rightNode;
}
//右樹爲空
if(node.right == null){
Node leftNode = node.left;
node.left = null;
count =count -1;
return leftNode;
}
//左右子樹都不爲空
//找到當前節點,右子數中最小節點;或者左子樹中最大的節點作爲新的跟節點;
Node successor = new Node(minimum(node.right));
successor.right = node.right;
successor.left = node.left;
node = null;
count --;
return successor;
}
}
}
}
算法基礎之--二分搜索樹(添加,刪除,深度優先遍歷,廣度優先遍歷)
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.