JavaScript 二叉树算法，二叉树创建实现，中序排序，前序排序，后序排序

最新推荐文章于 2025-07-09 22:30:31 发布

原创最新推荐文章于 2025-07-09 22:30:31 发布 · 537 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#JavaScript 二叉树算法，二叉树创建实现 #js 二叉树，中序排序，前序排序，后序排序 #二叉树排序

JavaScript 专栏收录该内容

23 篇文章

订阅专栏

本文介绍了二叉树的概念，包括满二叉树和完全二叉树的定义。通过讲解二叉树的结构和执行方式，展示了如何使用JavaScript进行二叉树的中序、前序和后序排序。这些排序算法在处理大量数据时效率较高，适用于不同场景，如升序、降序排列和节点删除等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉树

在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。
一棵深度为k，且有2^k-1个节点的二叉树，称为满二叉树。这种树的特点是每一层上的节点数都是最大节点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且最后一层或者是满的，或者是在右边缺少连续若干节点，则此二叉树为完全二叉树。具有n个节点的完全二叉树的深度为floor(log2n)+1。深度为k的完全二叉树，至少有2k-1个叶子节点，至多有2k-1个节点。。

以上是书面解答 —— 下面我总结一下

结构

二叉树结构

二叉树分为：根节点 —— 中间节点 ——叶子节点

根节点是没有子节点的
中间节点有子节点也有父节点
叶子节点只有父节点没有子节点

执行方式

小于父节点的节点放在左边大于的放在右边以此类推不断的递归

function BinaryTree () {
                //创建对象
                class Node {
                    constructor (key) {
                        this.key = key
                        this.left = null
                        this.right = null
                    }
                }
                //初始化root
                let root = null
                
                const  insertNode =  (node, newNode) => {
                        if (newNode.key < node.key) {
                        if (node.left === null) {
                            node.left = newNode
                        } else {
                            insertNode(node.left, newNode)
                        }
                    } else {
                        if (node.right === null) {
                            node.right = newNode
                        } else {
                            insertNode(node.right, newNode)
                        }
                    }
                }


                    
                this.insert = (item) =>{
                    let newNode = new Node(item)
                    if (root === null) {//判断是否有根节点
                        root = newNode
                    } else {
                        insertNode(root, newNode)//调用二叉处理方法
                    }
                }

                //中序排序
                const inOrderTraverseNode = (node, callback) => {
                    if (node !== null) {
                        inOrderTraverseNode(node.left, callback)
                        callback(node.key)
                        inOrderTraverseNode(node.right, callback)
                    }
                }

              

                //前序遍历
                const preOrderTraverseNode = (node, callback) => {
                    if (node !== null) {
                        callback(node.key)
                        preOrderTraverseNode(node.left, callback)
                        preOrderTraverseNode(node.right, callback)
                    }
                }

                

                //后序遍历
                const postOrderTraverseNode = (node, callback) => {
                    if (node !== null) {
                        postOrderTraverseNode(node.left, callback)
                        postOrderTraverseNode(node.right, callback)
                        callback(node.key)
                    }
                }

               

                this.allOrderTraverse = (callback, FuncName) => {//入口函数
                    switch (FuncName) {
                        case 'inOrderTraverseNode': inOrderTraverseNode(root, callback)
                            break
                        case 'preOrderTraverseNode': preOrderTraverseNode(root, callback)
                            break
                        case 'postOrderTraverseNode' : postOrderTraverseNode (root, callback)
                            break
                        default: alert('输入错误,请输入：inOrderTraverseNode，preOrderTraverseNode，postOrderTraverseNode 中的一种 ') 
                        break;
                    }
                }             

            }

            let nodes = [8, 3, 10, 1, 6, 14, 4, 7, 13]

            var BinaryTree = new BinaryTree()
            nodes.forEach(function (key) {
                BinaryTree.insert(key)
            })
            BinaryTree.allOrderTraverse(key => {console.log(key)}, 'postOrderTraverseNode')

复制这段代码到页面的script标签中断点调试

代码分析

Node 初始化的节点对象它包含 left right 属性
insert 判断是否有根节点，没有的话初始化当前的key为根节点
insterNode 执行二叉法
- 判断新节点的 left 和 right是否为空为空的话让其赋值
- 小于的放 left 大于的放 right
- 如果出现既小于 || 大于 又不为空的情况那就递归执行 insterNode（newNode.left || right , newNode） 置到能给子节点赋值为止

中序排序

代码实现

//中序排序
                const inOrderTraverseNode = (node, callback) => {
                    if (node !== null) {
                        inOrderTraverseNode(node.left, callback)
                        callback(node.key)
                        inOrderTraverseNode(node.right, callback)
                    }
                }

图片演示

二叉树—中序排序

前序排序

代码实现

//前序遍历
                const preOrderTraverseNode = (node, callback) => {
                    if (node !== null) {
                        callback(node.key)
                        preOrderTraverseNode(node.left, callback)
                        preOrderTraverseNode(node.right, callback)
                    }
                }

图片演示

后序排序

代码实现

 //后序遍历
                const postOrderTraverseNode = (node, callback) => {
                    if (node !== null) {
                        postOrderTraverseNode(node.left, callback)
                        postOrderTraverseNode(node.right, callback)
                        callback(node.key)
                    }
                }