二叉查找树

最新推荐文章于 2020-03-03 16:08:55 发布

dutsoft

最新推荐文章于 2020-03-03 16:08:55 发布

阅读量725

点赞数

分类专栏：数据结构文章标签：数据结构算法

本文链接：https://blog.csdn.net/dutsoft/article/details/27360401

版权

数据结构专栏收录该内容

27 篇文章 0 订阅

订阅专栏

import java.util.Random;

public class BST<Key extends Comparable<Key>,Value> {
	
	private Node root;
	private class Node{
		private Key key;
		private Value val;
		private Node left,right;
		private int N;
		public Node(Key key,Value val,int N){
			this.key=key;
			this.val=val;
			this.N=N;
		}
	}

	public int size() { return size(root); }
	private int size(Node x){
		if(x==null) return 0;
		else return x.N;
	}
	
	public Value get(Key key){
		return get(root,key);
	}
	private Value get(Node x,Key key){
		if(x==null) return null;
		//System.out.println(x.val);
		int cmp=key.compareTo(x.key);
		if(cmp<0) return get(x.left,key);
		else if(cmp>0) return get(x.right,key);
		else return x.val;
	}
	
	public void put(Key key,Value val){
		root=put(root,key, val);
	}
	public Node put(Node x,Key key,Value val){
		if(x==null) return new Node(key, val, 1);
		int cmp=key.compareTo(x.key);
		if(cmp<0) x.left=put(x.left,key,val);
		else if(cmp>0) x.right=put(x.right, key, val);
		else x.val=val;
		
		x.N=size(x.left)+size(x.right)+1;
		return x;
	}
	
	private Node min(Node x){
		if(x.left==null) return x;
		else return min(x.left);
	}
	
	public void deleteMin(){
		root=deleteMin(root);
	}
	private Node deleteMin(Node x){
		if(x.left==null) return x.right;
		x.left=deleteMin(x.left);
		x.N=size(x.left)+size(x.right)+1;
		return x;
	}
	
	public void delete(Key key){
		root=delete(root,key);
	}
	private Node delete(Node x,Key key){
		if(x==null) return null;
		int cmp=key.compareTo(x.key);
		if(cmp<0) x.left=delete(x.left, key);
		else if(cmp>0) x.right=delete(x.right, key);
		else{
			if(x.right==null) return x.left;
			if(x.left==null) return x.right;
			Node tNode=x;
			x=min(x.right);
			x.right=deleteMin(tNode.right);
			x.left=tNode.left;
		}
		x.N=size(x.left)+size(x.right)+1;
		return x;
	}
	
	public void PrevOrder(Node x){
		if(x==null) return;
		System.out.print(x.key+": "+x.val+"->");
		PrevOrder(x.left);
		PrevOrder(x.right);
	}
	public void InOrder(Node x){
		if(x==null) return;
		PrevOrder(x.left);
		System.out.print(x.key+": "+x.val+"->");
		PrevOrder(x.right);
	}
	public void PostOrder(Node x){
		if(x==null) return;
		PrevOrder(x.left);
		PrevOrder(x.right);
		System.out.print(x.key+": "+x.val+"->");
	}
	
	public static void main(String[] args) {
		BST<Integer, String> tree=null;
		tree=new BST<Integer,String>();
		for(int i=0;i<10;i++){
			tree.put(i*i-4*i,"value="+i);
		}
		tree.PrevOrder(tree.root);
		System.out.println();
		tree.InOrder(tree.root);
		System.out.println();
		tree.PostOrder(tree.root);
		System.out.println();
		
		tree.delete(0);
		tree.PrevOrder(tree.root);
		System.out.println();
		tree.delete(21);
		tree.PrevOrder(tree.root);
		System.out.println();
		tree.delete(45);
		tree.PrevOrder(tree.root);
		System.out.println();
	}

}

/*test
0: value=4->-3: value=3->-4: value=2->5: value=5->12: value=6->21: value=7->32: value=8->45: value=9->
-3: value=3->-4: value=2->0: value=4->5: value=5->12: value=6->21: value=7->32: value=8->45: value=9->
-3: value=3->-4: value=2->5: value=5->12: value=6->21: value=7->32: value=8->45: value=9->0: value=4->
5: value=5->-3: value=3->-4: value=2->12: value=6->21: value=7->32: value=8->45: value=9->
5: value=5->-3: value=3->-4: value=2->12: value=6->32: value=8->45: value=9->
5: value=5->-3: value=3->-4: value=2->12: value=6->32: value=8->
*/