二叉搜索树

欠的账总是要还的嘻嘻

定义

1. 非空左子树的所有键值小于其根结点的键值
2. 非空右子树的所有键值大于其根结点的键值
3. 左、右子树都是二叉搜索树

特点

1. 最小值在二叉搜索树的最左边
2. 最大值在二叉搜索树的最右边

结点定义

class BinaryTreeNode {
int val;
BinaryTreeNode leftNode;
BinaryTreeNode rightNode;

public BinaryTreeNode() {

}

public BinaryTreeNode(int val) {
    this.val = val;
}
}

插入

// 插入结点
public static BinaryTreeNode insertNode(BinaryTreeNode tree, int val) {
    //树空
    if (tree == null) {
        tree = new BinaryTreeNode(val);
    } else {
        if (tree.val > val) {
            tree.leftNode = insertNode(tree.leftNode, val);
        } else if (tree.val < val) {
            tree.rightNode = insertNode(tree.rightNode, val);
        } else {
            //已经有结点了不插入
        }
    }
    return tree;
}

创建

//创建二叉搜索树
public static BinaryTreeNode createBinarySearchTree(int[] array) {
    //没有数据
    if (array.length == 0) {
        return null;
    }
    BinaryTreeNode node = null;
    for (int i = 0; i < array.length; i++) {
        node = insertNode(node, array[i]);
    }
    return node;

}

查找二叉搜索树中的最小结点

//查找二叉搜索树中的最小结点
//最左边
public static BinaryTreeNode findMin(BinaryTreeNode tree) {
    if (tree == null) {
        System.out.println("二叉搜索树为空");
    }
    while (tree.leftNode != null) {
        tree = tree.leftNode;
    }
    return tree;
}

查找二叉搜索树中的最大值

 //查找二叉搜索树中的最大值
//最右边
public static BinaryTreeNode findMax(BinaryTreeNode tree) {
    if (tree == null) {
        System.out.println("二叉搜索树为空");
    }
    while (tree.rightNode != null) {
        tree = tree.rightNode;
    }
    return tree;
}

删除结点

//删除结点
public static BinaryTreeNode deleteBinaryTreeNode(BinaryTreeNode tree, int val) {
    if (tree == null) {
        //树空
        System.out.println("树空");
    }
    if (tree.val > val) {
        tree.leftNode = deleteBinaryTreeNode(tree.leftNode, val);
    } else if (tree.val < val) {
        tree.rightNode = deleteBinaryTreeNode(tree.rightNode, val);
    } else {
        //找到要删除的结点
        //有左孩子和右孩子
        if (tree.leftNode != null && tree.rightNode != null) {
            BinaryTreeNode tempNode=findMin(tree.rightNode);
            deleteBinaryTreeNode(tree,tempNode.val);
            tree.val=tempNode.val;
        } else {
            //只有一个孩子或一个孩子都没有
            if (tree.leftNode != null) {
                tree = tree.leftNode;
            } else {
                tree = tree.rightNode;
            }
        }
    }
    return tree;
}

按层遍历二叉搜索树

//按层遍历二叉搜索树
public static void traverseLayerOrder(BinaryTreeNode treeNode) {
    if (treeNode == null) {
        return;
    }
    //队列
    Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();
    int level = 1;
    queue.add(treeNode);
    while (!queue.isEmpty()) {
        //记录每层的个数
        int number = queue.size();
        System.out.print("第" + (level++) + "层：");
        while (number > 0) {
            //出队列
            BinaryTreeNode node = queue.poll();
            System.out.print("--------" + node.val);
            if (node.leftNode != null) {
                queue.add(node.leftNode);
            }
            if (node.rightNode != null) {
                queue.add(node.rightNode);
            }
            number--;
        }
        System.out.println();
    }
}

验证

public static void main(String[] args) {
    int[] data = {4, 2, 1, 3, 8, 7, 6, 9};
    BinaryTreeNode treeNode = createBinarySearchTree(data);
    traverseLayerOrder(treeNode);
    System.out.println("-----");
    treeNode=deleteBinaryTreeNode(treeNode,4);
    traverseLayerOrder(treeNode);
}

结果：