二分查找树的实现(Java)


前言

      Binary Search Tree,对其中任意一个节点,需要满足左子节点的值小于该节点的值,右子节点的值大于该节点的值。(左小右大)。

      其中序遍历为一个升序序列。

      下面来实现BST,分别有插入方法(迭代实现以及递归实现)、删除方法、判断树中是否包含某一元素、中序遍历打印BST以及分层遍历打印BST。

      具体的 Java 代码如下,可供参考:

代码实现

import java.util.ArrayDeque;
import java.util.Deque;

public class MyBST {
    private static class Node{
        int val;
        Node left,right;
        Node(int v){
            val=v;
        }
    }
    private Node root;
    private int size;
    MyBST(){};
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    /**
     *
     * @param v 在此树中插入 值为 v 的节点
     */
    public void insert1(int v){  // 迭代实现
        size++;
        if(root==null)
            root=new Node(v);
        else{
            Node tmp=root,parent=root;// 需要采用 parent 来标记该插入新元素的位置
            while(tmp!=null){
                parent=tmp;
                if(v>tmp.val)
                    tmp=tmp.right;
                else
                    tmp=tmp.left;
            }

            if(v< parent.val)
                parent.left=new Node(v);
            else
                parent.right=new Node(v);
        }
    }

    /**
     * 
     * @param v 在此树中插入 值为 v 的节点
     */
    public void insert2(int v){// 递归实现
        root= insertInRoot(root,v);
        size++;
    }
    private Node insertInRoot(Node cur, int v){
        //递归是 通过采用后序遍历来进行插入的
        if(cur==null)
            return new Node(v);
        if(v>cur.val)
            cur.right= insertInRoot(cur.right,v);
        else
            cur.left= insertInRoot(cur.left,v);
        return cur;
    }

    /**
     * 
     * @param v 查找是否含有值为 v 的节点。
     * @return true: 存在  false: 不存在
     */
    public boolean contains(int v){
        return containsInRoot(root,v);
    }
    private boolean containsInRoot(Node cur,int v){
        if(cur==null)
            return false;
        else if(v>cur.val)
            return containsInRoot(cur.right,v);
        else if(v<cur.val)
            return containsInRoot(cur.left,v);
        return true;
    }

    /**
     * 
     * @param v 删除值为 v 的节点
     * @return  如果此树中不包含 v,返回 false; 否则 删除值为 v 的节点,返回true
     */
    public boolean remove(int v){
        if(!contains(v))
            return false;
        root=removeInRoot(root,v);
        size--;
        return true;
    }
    private Node removeInRoot(Node cur,int v){
        if(cur.val==v){
            if(cur.left==null)
                return cur.right;
            if(cur.right==null)
                return cur.left;
			//下面代码找到左子树中的最大值 max,然后将其赋值给 cur.val。
			//然后在左子树中删除值为 max 的节点。
            Node tmp=cur.left;
            int max=tmp.val;
            while(tmp.right!=null){
                max=tmp.right.val;
                tmp=tmp.right;
            }
            cur.val=max;
            cur.left=removeInRoot(cur.left,max);
            return cur;
        }

        else if(v>cur.val)
            cur.right=removeInRoot(cur.right,v);
        else
            cur.left=removeInRoot(cur.left,v);
        return cur;
    }


    public void printInOrder(){ // 中序遍历打印 BST
        System.out.println("中序遍历:");
        inOrder(root);
        System.out.println();
    }
    public void printLayer(){ // 分层遍历打印 BST
        System.out.println("分层打印:");
        layer(root);
    }
    private void inOrder(Node cur){
        if(cur==null)
            return;
        inOrder(cur.left);
        System.out.print(cur.val+" ");
        inOrder(cur.right);
    }
    private void layer(Node cur){
        Deque<Node> q=new ArrayDeque<>();
        if(cur==null)
            return;
        q.offer(cur);

        while(!q.isEmpty()){
            int count=q.size();
            while(count!=0){
                Node tmp=q.poll();
                System.out.print(tmp.val+" ");
                if(tmp.left!=null)
                    q.offer(tmp.left);
                if(tmp.right!=null)
                    q.offer(tmp.right);
                count--;
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        MyBST bst=new MyBST();
        bst.insert2(2);
        bst.insert2(4);
        bst.insert2(8);
        bst.insert2(1);
        bst.insert2(7);
        bst.insert2(3);
        bst.printInOrder();
//        bst.printLayer();
        System.out.println(bst.size());

        bst.remove(3);
        bst.printInOrder();
//        bst.printLayer();
        bst.remove(1);
        bst.printInOrder();
//        bst.printLayer();
        System.out.println(bst.size());
    }
}

总结

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值