Java实现二叉搜索树

定义

二叉排序树(Binary Sort Tree),又称二叉查找树(Binary Search Tree),亦称二叉搜索树。

结构

二叉搜索树的建立过程.
这里写图片描述

特点

二叉排序树或者是一棵空树,或者是具有下列性质的二叉树:
(1)若左子树不空,则左子树上所有结点的值均小于或等于它的根结点的值;
(2)若右子树不空,则右子树上所有结点的值均大于或等于它的根结点的值;
(3)左、右子树也分别为二叉排序树;

遍历

前序遍历

规则:若二叉树为空,则空操作返回,否则先访问根节点,再前序遍历左子树,再后序遍历右子树.
遍历结果:A-B-D-E-C-F-G-H

这里写图片描述

中序遍历

规则:若二叉树为空,则空操作返回,否则先从根节点开始(注意不是先访问根节点),再中序遍历左子树,然后是访问根节点,再中序遍历右子树.
遍历结果:D-B-E-A-F-C-G-H
这里写图片描述

后序遍历

规则:若二叉树为空,则空操作返回,否则先从根节点开始(注意不是先访问根节点),再中序遍历左子树,再中序遍历右子树,然后是访问根节点.
遍历结果:D-E-B-F-H-G-C-A
这里写图片描述
可以从图形和遍历方式推倒出遍历结果,也可以从遍历结果和遍历方式推倒出图形.

实例

创建节点

从上面的结构可以看出节点包括三个属性,节点值,左子节点引用和右子节点引用.

public class Node {
    //节点值
    int   val;
    //左子节点引用
    Node  leftChild;
    //右子节点引用
    Node  rightChild;

    public void  printNode() {
        System.out.println(val);
    }
}

创建二叉搜索树

该类只有一个私有属性root以及相关方法,该私有属性指向其根节点.
也可以添加size作为节点数.

public class BinaryTree {

    private Node root;
}

插入节点

这里写图片描述
比如在上面的二叉搜索树插入35的值:
1.从根节点开始比较,35<50,从左子树查找插入位置,
parent = current; current=root.leftChild(25);
2.35>25,说明在其右子树添加,
parent = current; current=root.leftChild(null);
此时current==null,因此新节点30就在该位置添加.
parent.rightChild = newNode(30);

public void insert(int data) {
        Node  newNode = new Node();
        newNode.val = data;     
        if(root == null) {
            //如果是第一个节点,也就是根节点为null,直接创建一个新的节点即可 
            root = newNode;
        }
        else {
            Node current = root;
            //current节点的父节点
            Node parent;
            //循环查找插入的位置
            while(true) {
                parent = current;
                //如果插入的值小于当前节点的值,从左子树查找
                if(data < current.val) {
                    current = current.leftChild;
                    //直到当前节点为null
                    if(current == null) {
                        //设置当前节点的父节点的左子节点为新创建的节点
                        parent.leftChild = newNode;
                        return;
                    }

                }
                //如果插入的值大于当前节点的值,从左子树查找
                else {
                    current = current.rightChild;
                    //直到当前节点为null
                    if(current == null) {
                        //设置当前节点的父节点的右子节点为新创建的节点
                        parent.rightChild = newNode;
                        return;
                    }
                }
            }// end of while(true)
        }   
    }

查找节点

查找节点也是根据其特点进行查找,某个节点的值总比左子树的值大,比右子树的值小或者等于.

public Node find(int value) {

    Node current = root;

    while(current.val != value) {

        if(value < current.val) {
            current = current.leftChild;
        }
        else {
            current = current.rightChild;
        }
        if(current == null) {
            return null;
        }
    }

    return current;
}

删除节点

删除节点比较复杂,因为会出现以下几种情况;
1.删除的节点为叶节点,这个比较好处理,直接将该节点设置为null.
这里写图片描述
2.当删除的是中间节点,其子树如何处理.
2.1 存在左子节点
这里写图片描述
2.2 存在右子节点
这里写图片描述
2.3 存在左右子节点
这里写图片描述

public boolean delete(int value) {

        Node current = root;
        Node parent = root;
        boolean isLeft = false;
        boolean isRight = false;
        //查找所要删除的节点的左子节点还是右子节点
        while(current.val != value) {
            parent = current;
            isLeft = false;
            isRight = false;
            if(value < current.val) {
                current = current.leftChild;
                isLeft = true;
            }
            else {
                current = current.rightChild;
                isRight = true;
            }
        }
        //不存在该值
        if(current == null) {
            return false;
        }
        //是叶子节点,不存在子节点
        if((current.leftChild == null) 
            && (current.rightChild == null)) {
            System.out.println("是叶子节点,不存在子节点");
            if(isLeft) {
                //如果是左子节点,设父节点的左子节点为null
                parent.leftChild = null;
            }
            else if(isRight) {
                //如果是右子节点,设父节点的右子节点为null
                parent.rightChild = null;
            }
            return  true;
        }
        //存在左子节点
        else if((current.leftChild != null) 
                && (current.rightChild == null)) {
                System.out.println("不是叶子节点,存在左子节点");

                if(isLeft) {
                    parent.leftChild = current.leftChild;
                }
                else if(isRight) {
                    parent.rightChild = current.leftChild;
                }
                current = null;
                return  true;
        }

        //存在右子节点
        else if((current.leftChild == null) 
                && (current.rightChild != null)) {
                System.out.println("不是叶子节点,存在右子节点");                
                if(isLeft) {
                    parent.leftChild = current.rightChild; 

                }
                else if(isRight) {
                    parent.rightChild = current.rightChild; 
                }
                current = null;
                return  true;
        }
        //左右子节点都存在
        else {
            System.out.println("不是叶子节点,存在左右子节点");

            if(isLeft) {
                parent.leftChild = current.rightChild; 

                Node currentLeft = current.rightChild;
                Node parentLeft = currentLeft;
                while(currentLeft != null) {
                    parentLeft = currentLeft;
                    currentLeft = currentLeft.leftChild;
                }
                parentLeft.leftChild = current.leftChild;
                current = null;

            }
            else if(isRight) {
                parent.rightChild = current.rightChild; 

                Node currentLeft = current.rightChild;
                Node parentLeft = currentLeft;
                while(currentLeft != null) {
                    parentLeft = currentLeft;
                    currentLeft = currentLeft.leftChild;
                }
                parentLeft.leftChild = current.leftChild;
                current = null;
            }

            return  true;
        }

    }

遍历

前序遍历

public void preOrder(Node localNode) {

    if(localNode != null) {
        System.out.println(localNode.val);
        preOrder(localNode.leftChild);
        preOrder(localNode.rightChild); 
    }   
}

中序遍历

由于中序遍历是根据左(小)-中(中)-右(大),
因此,中序遍历所获得的数据是单调递增的.

public void inOrder(Node localNode) {

    if(localNode != null) {

        inOrder(localNode.leftChild);
        System.out.println(localNode.val);
        inOrder(localNode.rightChild);

    }   
}

后序遍历

public void posOrder(Node localNode) {

    if(localNode != null) {
        posOrder(localNode.leftChild);
        posOrder(localNode.rightChild);         
        System.out.println(localNode.val);
    }   
}

查找最小值

最小值一定位于根节点的左子树中,因此一直从根节点开始一直遍历其左子树,直到该节点没有左子节点.

public Node getMin() {
    Node current = root,last = null;

    while(current != null) {
        last = current;
        current = current.leftChild;
    }

    return last;

}

查找最大值

最小值一定位于根节点的右子树中,因此一直从根节点开始一直遍历其右子树,直到该节点没有右子节点.

public Node getMax() {
    Node current = root,last = null;

    while(current != null) {
        last = current;
        current = current.rightChild;
    }

    return last;        
}

打印二叉搜索树的树形结构

    public  void printTree(Node head) {  
        System.out.println("-----------------\r\nBinary Tree:");  
        printInOrder(head, 0, "Root-", 8);  
        System.out.println();  
    }  

    public  void printInOrder(Node head, int height, String to, int len) {  
        if (head == null) {  
            return;  
        }  
        printInOrder(head.rightChild, height + 1, "R-", len);  
        String val = to + head.val;  
        int lenM = val.length();  
        int lenL = (len - lenM) / 2;  
        int lenR = len - lenM - lenL;  
        val = getSpace(lenL) + val;// + getSpace(lenR);  
        System.out.println(getSpace(height * len) + val);  
        printInOrder(head.leftChild, height + 1, "L-", len);  
    }  

    public  String getSpace(int num) {  
        String space = " ";  
        StringBuffer buf = new StringBuffer("");  
        for (int i = 0; i < num; i++) {  
            buf.append(space);  
        }  
        return buf.toString();  
    } 

存在的问题

二叉搜索树插入时是按照一定规则进行插入的,因此在中序遍历时获得的数据是有序的,比如下面查找35,只需要比较3次就可以获得结果,因此插入或者查找的效率还是比较高的.
这里写图片描述
但是存在的一个问题是,如果插入的数据是单调变化的,那就变成了线性链表,最后导致查找效率降低.
因此,也就出现了其他更好的二叉树数据结构,比如红黑树,红黑树是一种平衡的二叉树,后面琢磨明白了再另写一篇进行说明.

已标记关键词 清除标记
做一门精致,全面详细的 java数据结构与算法!!! 让天下没有难学的数据结构, 让天下没有难学的算法, 不吹不黑,我们的讲师及其敬业,可以看到课程视频,课件,代码的录制撰写,都是在深夜,如此用心,其心可鉴,他不掉头发,谁掉头发??? 总之你知道的,不知道的,我们都讲,并且持续更新,走过路过,不要错过,不敢说是史上最全的课程,怕违反广告法,总而言之,言而总之,这门课你值得拥有,好吃不贵,对于你知识的渴求,我们管够管饱 话不多说,牛不多吹,我们要讲的本门课程内容: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉、二叉与数组转换、二叉排序(BST)、AVL、线索二叉、赫夫曼、赫夫曼编码、多路查找(BB+和B*)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页