二叉树

1、定义：

• 是一颗树
• 每个节点，做多有两个字节点
• 节点的数据结构{value,left?,right?}

2、遍历

• 前序遍历：root,left,right（跟节点在最前）
• 中序遍历：left,root,right（跟节点在中间）
• 后序遍历：left,right,root（跟节点在最后）

遍历结果：

1. 前序遍历：5，3，2，4，7，6，8
2. 中序遍历：2，3，4，5，6，7，8
3. 后序遍历：2，4，3，6，8，7，5

3、二叉搜索树

• left(及其子节点) value<=root value
• right(及其子节点) value>=root value
• 可使用二分法快速查找

4、练习

前序/中序/后序遍历

/**
 * 二叉树遍历
 * 前序/中序/后序遍历
 */

export interface ITreeNode{
    value:number,
    left?:ITreeNode|null,
    right?:ITreeNode|null
}

const tree:ITreeNode={
    value:5,
    left:{
        value:3,
        left:{
            value:2,
            left:null,
            right:null
        },
        right:{
            value:4,
            left:null,
            right:null
        }
    },
    right:{
        value:7,
        left:{
            value:6,
            left:null,
            right:null
        },
        right:{
            value:8,
            left:null,
            right:null
        }
    }
}

// 前序遍历--跟节点在最前
export function prevOrderTraversal (node:ITreeNode|null|undefined){
    if(node==null) return
    console.log(node.value)
    prevOrderTraversal(node.left)
    prevOrderTraversal(node.right)
}

// 中序遍历--跟节点在中间
export function middOrderTraversal (node:ITreeNode|null|undefined){
    if(node==null) return
    middOrderTraversal(node.left)
    console.log(node.value)
    middOrderTraversal(node.right)
}

// 后序遍历--跟节点在最后
export function nextOrderTraversal (node:ITreeNode|null|undefined){
    if(node==null) return
    nextOrderTraversal(node.left)
    nextOrderTraversal(node.right)
    console.log(node.value)
}

// 功能测试
// prevOrderTraversal(tree) // 5 3 2 4 7 6 8
// middOrderTraversal(tree) // 2 3 4 5 6 7 8
// nextOrderTraversal(tree) // 2 4 3 6 8 7 5

求二叉搜索树中第k小的值

/**
 * 求二叉搜索树中第k小的值
 * 中序遍历等到生序数组，数组取值
 */
 export interface ITreeNode{
    value:number,
    left?:ITreeNode|null,
    right?:ITreeNode|null
}

 const tree:ITreeNode={
    value:5,
    left:{
        value:3,
        left:{
            value:2,
            left:null,
            right:null
        },
        right:{
            value:4,
            left:null,
            right:null
        }
    },
    right:{
        value:7,
        left:{
            value:6,
            left:null,
            right:null
        },
        right:{
            value:8,
            left:null,
            right:null
        }
    }
}

let result:number[]=[]

// 中序遍历--跟节点在中间
export function middOrderTraversal (node:ITreeNode|null|undefined){
    if(node==null) return
    middOrderTraversal(node.left)
    result.push(node.value)
    middOrderTraversal(node.right)
}

export function getKthValue(node:ITreeNode,k:number):number{
    middOrderTraversal(node)
    return result[k-1]
}

// 功能测试
console.info(getKthValue(tree,3)) // 4