二分搜索树删除

寻找二分搜索树中最小的元素

//寻找二分搜索树最小元素
public E minimum() {
	if(size==0)
		throw new IllegalArgumentException("BST is empty");
	return minimum(root).e;
}
//返回以node为根的二分搜索树最小键值所在节点
private Node minimum(Node node) {
	if(node.left==null)
		return node;
	return minimum(node.left);
	
}

最大 右边同理

删除二分搜索树中最小的元素

//从二分搜索树中删除最小值所在节点，返回最小值	
public E removeMin() {
	E ret =minimum();
	root=removeMin(root);
	return ret;
}
//删除以node为根的二分搜索树最小节点
//返回删除节点后新的二分搜索树的根
private Node removeMin(Node node) {
	if(node.left==null) {
		Node rightNode=node.right;
		node.right=null; //与当前节点脱离关系
		size--;
		return rightNode;
	}
	node.left=removeMin(node.left);
	return node; 	
}

测试用例

public static void main(String[] args) {
	BST<Integer> bst=new BST<>();
	Random random=new Random();
	
	int n=1000;
	for(int i=0;i<n;i++)
		bst.add(random.nextInt(10000));
	ArrayList<Integer> nums=new ArrayList<>();
	while(!bst.isEmpty())
		nums.add(bst.removeMin());
	System.out.println(nums);
	for(int i=1;i<nums.size();i++)
		if(nums.get(i-1)>nums.get(i))
			throw new IllegalArgumentException("Error ");
	System.out.println("removeMin test completed");
}

删除二分搜索树中任意元素

//从二分搜索树中删除元素为e的节点
public void remove(E e) {
	root = remove(root,e);
}

//删除以node为根的二分搜索树中值为e的节点，递归算法
//返回删除节点后新的二分搜索树的根

private Node remove(Node node, E e) {
	if(node==null)
		return null;
	if(e.compareTo(node.e)<0) {
		node.left=remove(node.left,e);
		return node;
	}
	else if(e.compareTo(node.e)>0) {
		node.right=remove(node.right,e);
		return node;
	}
	else {  //e==node.e
		//待删除节点左子树为空的情况
		if(node.left==null) {
			Node rightNode=node.right;
			node.right=null;
			size--;
			return rightNode;
		}
		//待删除节点左子树为空的情况
		if(node.right==null) {
			Node leftNode=node.left;
			node.left=null;
			size--;
			return leftNode;
		}
		//待删除节点左右子树均不为空的情况
		//找到比这个待删除节点大的最小节点，即待删除节点右字数的的最小节点
		//用这个节点顶替待删除节点位置
		Node successor = minimum(node.right);
		successor.right=removeMin(node.right);//新的代替的节点右子树为删除最小值的树
		successor.left =node.left;
		node.left=node.right=null;
		return successor;
	}	
}