二分搜索树
二分搜索树的特性
二分搜索树的每个节点的值:
- 大于其左子树的所有节点的值
- 小于其右子树的所有节点的值
二分搜索树存储的元素必须具有可比较性。
二分搜索树添加元素
因为整体代码较长,只给出部分核心代码,下文同样如此。
采用递归算法插入元素
//向二分搜索树添加新的元素e
public void add(E e) {
root = add(root,e);
}
//向以node为根的二分搜索树中插入元素E,递归算法
//返回插入新节点后二分搜索树的根
private Node add(Node node, E e) {
if (node == null){
size ++;
return new Node(e);
}
if (e.compareTo(node.e) < 0)
node.left = add(node.left,e);
else if (e.compareTo(node.e) > 0)
node.right = add(node.right,e);
return node;
}
二分搜索树的查询操作
//看二分搜索树中是否包含e
public boolean contains(E e){
return contains(root,e);
}
//看以node为根的二分搜索树中是否包含e,递归算法
private boolean contains(Node node,E e){
if (node == null)
return false;
if (e.compareTo(node.e) == 0)
return true;
else if (e.compareTo(node.e) < 0)
return contains(node.left,e);
else
return contains(node.right,e);
}
二分搜索树的深度优先遍历
- 遍历操作就是把所有节点都访问一遍
- 前序遍历:先访问当前节点,再依次递归访问左右子树。
- 中序遍历:先递归访问左子树,再访问自身节点,再递归访问右子树。
- 后序遍历:先递归访问左右子树,再访问自身节点。
前序遍历:
//二分搜索树的前序遍历
public void preOrder(){
preOrder(root);
}
//前序遍历以node为根的二分搜索树,递归算法
private void preOrder(Node node) {
if (node != null) {
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
}
//二分搜索树的非递归前序遍历
public void preOrderNR(){
Stack<Node> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()){
Node cur = stack.pop();
System.out.println(cur);
if (cur.right!=null)
stack.push(cur.right);
if (cur.left!=null)
stack.push(cur.left);
}
}
中序遍历:
//二分搜索树的中序遍历
public void inOrder(){
inOrder(root);
}
//中序遍历以node为根的二分搜索树,递归算法
private void inOrder(Node node){
if (node == null)
return;
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}
后序遍历:
//二分搜索树的后序遍历
public void postOrder(){
postOrder(root);
}
//后序遍历以node为根的二分搜索树,递归算法
private void postOrder(Node node){
if (node == null)
return;
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
二分搜索树的广度优先遍历(层序遍历)
//二分搜索树的层序遍历
public void levelOrder(){
Queue<Node> q = new LinkedList<>();
q.add(root);
while (!q.isEmpty()){
Node cur = q.remove();
System.out.println(cur.e);
if (cur.left!=null)
q.add(cur.left);
if (cur.right!=null)
q.add(cur.right);
}
}
二分搜索树的删除操作(删除最大值和最小值)
//寻找二分搜索树的最小元素
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 maximum() {
if (size == 0) {
throw new IllegalArgumentException("BST is empty!");
}
return maximum(root).e;
}
//返回以node为根的二分搜索树的最大值所在的节点
private Node maximum(Node node) {
if (node.right == null)
return node;
return maximum(node.right);
}
//从二分搜索树中删除最小值所在节点,返回最小值
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 E removeMax() {
E ret = maximum();
root = removeMax(root);
return ret;
}
//删除掉以node为根的二分搜索树中的最大节点
//返回删除节点后新的二分搜索树的根
private Node removeMin(Node node) {
if (node.right == null) {//当没有右孩子时
Node leftNode = node.left;//保存当前节点的右子树
node.left = null;
size--;
return leftNode;
}
node.right = removeMax(node.right);//当有右孩子时
return node;
}
二分搜索树的删除操作(删除任意节点)
先讲一下最特殊的:删除左右都有孩子的节点。
- 删除左右都有孩子的节点d,找到s = min(d->right),s是d的后继。
- s->right = delMin(d->right)
- s->left = d->left
- 删除d,s是新的子树的根
具体步骤如下。(图不是自己画的,借助这个网站https://visualgo.net/zh/bst生成的。为啥不自己画因为懒。。这个网站很好的演示了各种数据结构的各种操作。)
找到比待删除节点大的最小节点,用这个节点顶替待删除节点的位置。
//从二分搜索树中删除元素为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){
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;
}
}