數據結構之: 二叉排序樹

數據結構學習之:二叉排序樹

二叉排序樹概述

二叉排序樹的規則比較簡單:二叉排序樹又名二叉搜索樹(BST),對於二叉樹中任何一個葉子節點,要求其左子節點小於當前節點,右子節點大於當前節點。根據名字我們可以知道這種二叉樹結構它的查找效率是比較高的

如圖所示:
在這裏插入圖片描述
它的中序遍歷爲:1 3 5 7 10 19 23
其實二叉排序樹的中序遍歷就是一個有序的數組

二叉排序樹代碼實現

package tree;

/**
 * 二叉排序樹
 */
public class SortBinaryNode {
    private int value;
    private SortBinaryNode leftNode;
    private SortBinaryNode rightNode;

    public void setValue(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public SortBinaryNode(int value) {
        this.value = value;
    }

    public SortBinaryNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(SortBinaryNode leftNode) {
        this.leftNode = leftNode;
    }

    public SortBinaryNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(SortBinaryNode rightNode) {
        this.rightNode = rightNode;
    }
    /**
     * 中序遍歷二叉排序樹
     */
    public void middleShow(SortBinaryNode node) {
        if (node == null) {
            return;
        }
        middleShow(node.getLeftNode());
        System.out.println(node.getValue());
        middleShow(node.getRightNode());
    }

    /**
     * @param value
     * @return
     */
    public SortBinaryNode search(int value) {
        if (this.getValue() == value){
            return this;
        }
        if (this.getValue()>value){
            return this.getLeftNode().search(value);
        }
        if (this.getValue()<value){
            return this.getRightNode().search(value);
        }

        return null;
    }
    /**
     * 搜索父節點
     *
     * @param value
     */
    public SortBinaryNode searchParent(int value) {
        if (this.getLeftNode()!=null && this.getLeftNode().getValue() == value ||
        this.getRightNode()!=null&& this.getRightNode().getValue()==value){
            return this;
        }
        else {
            if (this.value<value&&this.getLeftNode()!=null){
                return this.getLeftNode().searchParent(value);
            }
            if (this.value>value&&this.getRightNode()!=null){
                return this.getRightNode().searchParent(value);
            }
        }
        return null;
    }
}

package tree;

public class BinarySortTree {
    private SortBinaryNode root;

    /**
     * 添加二叉排序樹
     *
     * @param node
     */
    public void add(SortBinaryNode node) {
        if (node == null) {
            return;
        }
        //判斷當前節點的大小
        if (node.getValue() < root.getValue()) {
            if (root.getLeftNode() == null) {
                root.setLeftNode(node);
            } else {
                add(node);
            }
        } else {
            if (root.getRightNode() == null) {
                root.setRightNode(node);
            } else {
                this.add(node);
            }
        }
    }

    /**
     * 刪除節點
     *
     * @param value
     */
    public void delete(int value) {
        if (root == null) {
            return;
        }
        SortBinaryNode target = root.search(value);
        SortBinaryNode parent = root.searchParent(value);
        //刪除節點
        if (target.getLeftNode()==null&&target.getRightNode()==null){
            if (parent.getRightNode().getValue() == value){
                parent.setRightNode(null);
            }
            if (parent.getLeftNode().getValue()==value){
                parent.setLeftNode(null);
            }
        }
        //  刪除有兩個子節點的情況
        else if(target.getLeftNode()!=null&& target.getRightNode()!=null){
            int min = deleteMin(target.getRightNode());
            target.setValue(min);

        }
        //刪除只有一個節點的情況
        else {
            if (target.getLeftNode()!=null){
                if (parent.getLeftNode().getValue()== value){
                    parent.setLeftNode(target.getLeftNode());
                }else {
                    parent.setRightNode(target.getLeftNode());
                }
            }
            else {
                if (parent.getRightNode().getValue()==value){
                    parent.setLeftNode(target.getRightNode());
                }else {
                    parent.setRightNode(target.getRightNode());
                }
            }
        }
    }

    private int deleteMin(SortBinaryNode node) {
        SortBinaryNode target = node;
        while (node.getLeftNode()!=null){
            target = node.getLeftNode();
        }
        delete(target.getValue());
        return target.getValue();
    }


}

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章