數據結構筆記--二叉查找樹概述以及java代碼實現

一些概念:

　　二叉查找樹的重要性質:對於樹中的每一個節點X,它的左子樹任一節點的值均小於X,右子樹上任意節點的值均大於X.

　　二叉查找樹是java的TreeSet和TreeMap類實現的基礎.

　　由於樹的遞歸定義,二叉查找樹的代碼實現也基本上都是使用遞歸的函數,二叉查找樹的平均深度是O(logN).

　　因為二叉查找樹要求所有的節點都可以進行排序.所以編寫時代碼時需要一個Comparable泛型接口,當需要對類中的對象進行排序的時候,就需要實現這個泛型接口,里邊定義了一個public int compareTo(Object o)方法,接受一個Object作為參數,java中String,Integer等類都實現了這個接口.

java代碼實現:

　　remove方法:在查找樹的代碼實現中,最難得是刪除,因為這涉及到三種情況:

　　　　被刪除節點是樹葉節點(沒有子樹):最簡單,直接刪除,將該節點置為null即可

　　　　被刪除節點有一個子節點(左子樹或右子樹):是該節點的父節點指向該節點的子節點(左或右).見圖1

　　　　被刪除節點有兩個子節點:用其右子樹中的最小值代替該節點上的值,刪除其右子樹上的最小值.見圖2.

　　

package com.wang.tree;

public class BinarySearchTree<T extends Comparable<T>>{

    
    private static class Node<T>{
        private T data;
        private Node<T> left;
        private Node<T> right;
        
        public Node(T data){
            this(data,null,null);
        }
        public Node(T data, Node<T> left, Node<T> right) {
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }
    
    //私有變量 根節點root
    private Node<T> root;
    
    //無參構造函數,根節點為null
    public BinarySearchTree(){
        root=null;
    }
    
    //清空二叉查找樹
    public void makeEmpty(){
        root=null;
    }
    //判斷樹是否為空
    public boolean isEmpty(){
        
        return root==null;
    }
    //查找集合中是否有元素value,有返回true
    public boolean contains(T value){
        
        return contains(value,root);
    }
    
    private boolean contains(T value, Node<T> t) {
        
        if(t==null){
            return false;
        }
        int result=value.compareTo(t.data);
        if(result<0){
            return contains(value,t.left);
        }else if(result>0){
            return contains(value,t.right);
        }else{
            return true;
        }
    }

    //查找集合中的最小值
    public T findMin(){
        
        return  findMin(root).data;
    }
    private Node<T> findMin(Node<T> t) {
        if(t==null){
            return null;
        }else if(t.left==null){
            return t;
        }
        
        
        return findMin(t.left);
    }

    //查找集合中的最大值
    public T findMax(){
        
        return findMax(root).data;
    }
    
    private Node<T> findMax(Node<T> t) {
        if(t!=null){
            while(t.right!=null){
                t=t.right;
            }
        }
        
        return t;
    }

    //插入元素
    public void insert(T value){
        
        root =insert(value,root);
    }

    private Node<T> insert(T value, Node<T> t) {
        if(t==null){
            return new Node(value,null,null);
        }
        int result=value.compareTo(t.data);
        if(result<0){
            t.left=insert(value,t.left);
        }else if(result>0){
            t.right=insert(value,t.right);
        }
        return t;
    }
    //移除元素
    public void remove(T value){
        root=remove(value,root);
        
        
    }

    private Node<T> remove(T value, Node<T> t) {
        if(t==null){
            return t;
        }
        
        int result=value.compareTo(t.data);
        if(result<0){
            t.left=remove(value,t.left);
        }else if(result>0){
            t.right=remove(value,t.right);
        }else if(t.left!=null&&t.right!=null){//如果被刪除節點有兩個兒子
            //1.當前節點值被其右子樹的最小值代替
            t.data=findMin(t.right).data;
            //將右子樹的最小值刪除
            t.right=remove(t.data, t.right);
        }else{
            //如果被刪除節點是一個葉子 或只有一個兒子
            t=(t.left!=null)?t.left:t.right;
        }
        
        return t;
    }
    
    //中序遍歷打印
    public void printTree(){
        printTree(root);
    }

    private void printTree(Node<T> t) {
        
        if(t!=null){
            printTree(t.left);
            System.out.println(t.data);
            printTree(t.right);
        }
    }
}

　　測試代碼:

package com.wang.tree;

public class TestBST {

    public static void main(String[] args) {
        
        BinarySearchTree<Integer> bst=new BinarySearchTree<>();
        bst.insert(5);
        bst.insert(7);
        bst.insert(3);
        bst.insert(1);
        bst.insert(9);
        bst.insert(6);
        bst.insert(4);
        System.out.println("最小值:"+bst.findMin());
        System.out.println("最大值:"+bst.findMax());
        System.out.println("查找元素9是否存在:"+bst.contains(9));
        System.out.println("查找元素8是否存在:"+bst.contains(8));
        System.out.println("遍歷二叉樹");
        bst.printTree();
    }
}

打印結果:

最小值:1
最大值:9
查找元素9是否存在:true
查找元素8是否存在:false
遍歷二叉樹
1
3
4
5
6
7
9