二叉搜索树

定义

二叉搜索树又称[二叉查找树/二叉排序树]（Binary Search Tree => BST）。特点 根节点左侧所有节点值都小于根节点，根节点的右侧都大于根节点；它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；空树叶属于二叉搜索树

二叉搜索树中的搜索

递归法

function searchBST(root: TreeNode | null, val: number): TreeNode | null {
    const searchDfs = (node: TreeNode | null) => {
        if (node === null) {
            return null;
        }
        if (node.val === val) {
            return node;
        } else if (val < node.val) {
            return searchDfs(node.left);
        } else {
            return searchDfs(node.right);
        }
    }
    return searchDfs(root);
};

验证二叉搜索树

解法一： 范围值+递归
function isValidBST(root: TreeNode | null): boolean {
    const checkDfs = (node: TreeNode|null, left: number, right: number) => {
        if (node === null) return true;
        //比较当前节点的是否在范围内
        return (node.val > left && node.val < right && checkDfs(node.left, left, node.val) && checkDfs(node.right, node.val,right));
    }
    //Number.NEGATIVE_INFINITY 负无穷
    //Number.POSITIVE_INFINITY 正无穷
    return checkDfs(root, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY);
};

// 解法二： 范围值+递归法
function isValidBST(root: TreeNode | null): boolean {
    if (root === null) { return true; }
     //定义函数
    const isRecurse = (node: TreeNode, lower: number| null, upper: number| null) => {
        //如果上界和下界存在，判断是是否在界内，如果不再界内，返回false
        if (lower !== null && lower >= node.val) { return false; }
        if (upper !== null && upper <= node.val) { return false; }

        //将当前节点的上界作为上界，对node.right进行递归
        if (node.right && !isRecurse(node.right,node.val, upper)) {
            return false;
        }
        //将当前节点作为上界，对node.left进行递归
        if (node.left && !isRecurse(node.left,lower, node.val)) {
            return false;
        }
        
        return true;     
    }
    return isRecurse(root,null,null);
};

//解法三 利用中序遍历输出符合 二叉搜索树的原则。拿到所有值，比较数组中前一个值是否小于后一个值
function isValidBST(root: TreeNode | null): boolean {
    if (root === null) { return false; }
    const res: number[] = [];
    const midDfs = (node: TreeNode) => {
        if (node.left) {
            midDfs(node.left);
        }
        res.push(node.val);
        if (node.right) {
            midDfs(node.right);
        }
    }
    midDfs(root);

    if (res.length === 1) { return true; }
    for (let i = 1; i < res.length; i++) {
         console.log(res[i-1],res[i]);
        if (res[i-1] >= res[i]) {
            return false;
        }
    }
    return true;
};

展平二叉搜索树

中序遍历之后生成新的树

function increasingBST(root: TreeNode | null): TreeNode | null {
    const list = [];
    const dfs = (node: TreeNode|null) => {
        if (node === null) return;
        dfs(node.left);
        list.push(node.val);
        dfs(node.right);
    }
    dfs(root);

    let tempNode = new TreeNode();
    const ansNode = tempNode;
    for (let i of list) {
        tempNode.right = new TreeNode(i);
        tempNode = tempNode.right;
    }
    
    return ansNode.right;
};

平衡二叉树

平衡二叉树：

1. 是二叉搜索树
2. 每个节点平衡因子的绝对值 <= 1

在二叉搜索树中，树的高度最小，平均查找长度越小 平衡因子： 左子树的高度 - 右子树的高度

平衡二叉树判断

function isBalanced(root: TreeNode | null): boolean {
    if (root === null) return true;
    //判断每个节点的左右子树是平衡因子是否<= 1
    if (Math.abs(deep(root.left) - deep(root.right)) <= 1 
    && isBalanced(root.left) 
    && isBalanced(root.right)) {
        return true;
    }
    return false;
};

//递归 计算树的深度
function deep(node: TreeNode|null): number {
    let maxDeep = 0;
    const countDeep = (node: TreeNode|null, tempDeep: number) => {
        if (node === null) return;

        if (node.left === null && node.right === null) {
            maxDeep = Math.max(maxDeep, tempDeep);
        }
        countDeep(node.left, tempDeep + 1);
        countDeep(node.right, tempDeep + 1);
    }
    countDeep(node,1);
    return maxDeep;
}

满二叉树

定义

• 国内定义： 每层节点数最大 （2^(n - 1)）

• 国外定义： 除叶子节点外，每个节点的度都为2

完全二叉树