package leetcode.May;
import java.util.ArrayList;
import java.util.List;
/**
* @description: 二叉查找树
* @author: qiangyuecheng
* @date: 2022/5/31 17:00
*/
public class BST<Key extends Comparable<Key>,Value>{
public class Node{
private Key key;
private Value value;
private Node left;
private Node right;
public int num;
public Node(Key key,Value value){
this.key = key;
this.value = value;
this.left = null;
this.right = null;
this.num = 1;
}
}
private Node master;
public void put(Key key,Value value){
if(master==null){
master = new Node(key,value);
}else {
Node node = new Node(key,value);
put(master,node);
}
}
public Node put(Node lord,Node node){
if(lord==null){
return node;
}
int bool = node.key.compareTo(lord.key);
if(bool>0){
lord.right = put(lord.right,node);
}else if(bool<0){
lord.left = put(lord.left,node);
}else {
System.out.println("key不能重复");
return null;
}
lord.num = getNum(lord.right)+getNum(lord.left)+1;
return lord;
}
public int getNum(Node node){
if(node!=null){
return node.num;
}else {
return 0;
}
}
public Node get(Key key){
return get(key,master);
}
public Node get(Key key,Node node){
if(node==null){
System.out.println("没有");
return null;
}
int bool = key.compareTo(node.key);
if(bool==0){
return node;
}
if(bool>0){
return get(key,node.right);
}else {
return get(key,node.left);
}
}
/**
* 查找排名为k的节点
*/
public void select(int k){
System.out.printf(""+ select(master, k).value);
}
public Node select(Node node,int k){
if(node==null){
return null;
}
int n = getNum(node.left);
if(n>k){
return select(node.left,k);
}else if(n<k){
return select(node.right,k-n-1);
}else {
return node;
}
}
/**
* 查找范围的key个数
*/
public void select(Key key1,Key key2){
List<Node> list = new ArrayList<>();
select(master,key1,key2,list);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).key);
}
}
public void select(Node node,Key key1,Key key2,List list){
if (node==null){
return;
}
int a = node.key.compareTo(key1);
if(a>=0){
select(node.left,key1,key2,list);
}
int b = node.key.compareTo(key2);
if(a>=0&&b<=0){
list.add(node);
}
if(b<=0){
select(node.right,key1,key2,list);
}
}
/**
* 返回以x为根结点的子数中小于x.key的键的数量
*/
public void rank(Key k){
System.out.println(rank(master,k));
}
public int rank(Node node,Key k){
if(node==null){
return 0;
}
int t = node.key.compareTo(k);
if(t>0){
return rank(node.left,k);
}else if(t<0){
return rank(node.right,k)+getNum(node.left)+1;
}else {
return getNum(node.left);
}
}
/**
* 删除最大键
*/
public void deleteMax(){
master = deleteMax(master);
}
public Node deleteMax(Node node){
if(node.right==null){
if(node.left!=null){
return node.left;
}
return null;
}
node.right = deleteMax(node.right);
node.num = getNum(node.left)+getNum(node.right)+1;
return node;
}
/**
* 删除最小键
*/
public void deleteMin(){
master = deleteMin2(master);
}
public Node deleteMin(Node node){
if(node.left==null){
if(node.right!=null){
return node.right;
}
return null;
}
node.left = deleteMin(node.left);
node.num = getNum(node.left)+getNum(node.right)+1;
return node;
}
/**
* 删除key键
*/
public void delete(Key key){
master = delete(master,key);
}
public Node delete(Node node,Key key){
//找到
int t = node.key.compareTo(key);
if(t>0){
node.left = delete(node.left,key);
}else if(t<0){
node.right = delete(node.right,key);
}else {
if(node.left==null){
return node.right;
}
if(node.right==null){
return node.left;
}
//替换右子树最小结点
//找到最小结点
Node tmp = node;
node = getMin(tmp.right);
//删除最小结点 这里必须是先right后left 因为没删tmp.right之前不能给node.left赋值,
// 因为node是要删除的结点,赋值以后会导致循环引用
node.right = deleteMin2(tmp.right);
node.left = tmp.left;
}
node.num = getNum(node.left)+getNum(node.right)+1;
return node;
}
public Node getMin(Node node){
if(node==null){
return null;
}
if(node.left!=null){
return getMin(node.left);
}else {
return node;
}
}
public Node deleteMin2(Node node){
if(node.left==null){
if(node.right!=null){
return node.right;
}
return null;
}
node.left = deleteMin2(node.left);
node.num = getNum(node.left)+getNum(node.right)+1;
return node;
}
/**
* show
*/
public void show(Node node){
iteration(node);
}
public void show(){
iteration(master);
}
/**
* 中序遍历
*/
public void iteration(Node node){
if(node==null){
return;
}
if(node.left!=null){
iteration(node.left);
}
System.out.println(node.value);
if(node.right!=null){
iteration(node.right);
}
}
public static void main(String[] args) {
BST bst = new BST();
bst.put("e","555");
bst.put("b","222");
bst.put("a","111");
bst.put("c","333");
bst.put("d","444");
bst.put("f","666");
//System.out.printf(""+ bst.get("b").value);
//bst.select(5);
//bst.show();
//bst.select("b","d");
//bst.rank("d");
//bst.show();
//bst.deleteMin();
//System.out.println();
//bst.show();
//bst.select("b","d");
//bst.deleteMax();
//bst.deleteMax();
//bst.deleteMin();
bst.delete("f");
bst.show();
}
}
二叉查找树实现
最新推荐文章于 2023-01-23 18:29:24 发布