Javascript实现二叉树算法

最新推荐文章于 2022-06-28 15:29:44 发布
最新推荐文章于 2022-06-28 15:29:44 发布
阅读量327 收藏 3
点赞数 1
分类专栏： 二叉树 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wo_921110/article/details/102503472
版权

目录

 

二叉树算法原理及代码实现

二叉树定义

中序遍历

前序遍历

后序遍历

二叉树节点查找

二叉树叶子节点的删除原理及实现

二叉树算法原理及代码实现

二叉树定义

8：二叉树的根节点

4、7、13：二叉树的叶子节点

其他：中间节点

排序二叉树：

特点：节点的左子节点小于当前节点，节点的右子节点大于当前节点

代码实现：

<!DOCTYPE html>
<html>
  <head>
    <title>binaryTree</title>
  </head>
  <body>
    <script type="text/javascript">
      function BinaryTree() {
        var Node = function(key) {
          this.key = key;
          this.left = null;
          this.right = null;
        }

        var root = null;
        
        var insertNode = function (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 = function (key) {
          var NewNode = new Node(key)
          if(root === null) {
            root = NewNode
          } else {
            insertNode(root, NewNode);
          }
        }
      }

      var nodes = [8,3,10,1,6,14,4,7,13];
      var binaryTree = new BinaryTree();
      nodes.forEach(function(key){
        binaryTree.insert(key)
      })
    </script>
  </body>
</html>

中序遍历

原理：判断当前节点是否有左子节点，有的话，先遍历整个的左子树，再输出当前节点，最后遍历整个右子树

代码实现：

<!DOCTYPE html>
<html>
  <head>
    <title>binaryTree</title>
  </head>
  <body>
    <script type="text/javascript">
      function BinaryTree() {
        var Node = function(key) {
          this.key = key;
          this.left = null;
          this.right = null;
        }

        var root = null;
        
        var insertNode = function (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 = function (key) {
          var NewNode = new Node(key)
          if(root === null) {
            root = NewNode
          } else {
            insertNode(root, NewNode);
          }
        };

        var inOrderTraverseNode = function (node,callback) {
          if(node !== null) {
            inOrderTraverseNode(node.left,callback);
            callback(node.key);
            inOrderTraverseNode(node.right,callback)
          }
        }

        this.inOrderTraverse = function(callback) {
          inOrderTraverseNode(root,callback);
        }
      }

      var nodes = [8,3,10,1,6,14,4,7,13];
      var binaryTree = new BinaryTree();
      nodes.forEach(function(key){
        binaryTree.insert(key);
      })

      var callback = function (key) {
        console.log(key);
      }

      binaryTree.inOrderTraverse(callback);
    </script>
  </body>
</html>

注意打断点可以看到执行过程

 

执行结果：

前序遍历

原理：先打印当前节点，然后找到当前节点的左子树，然后再打印当前节点的左子树，然后找到左子树的左子树，最后打印右子树(可以复制当前的二叉树，效率更高)

代码实现：

<!DOCTYPE html>
<html>
  <head>
    <title>binaryTree</title>
  </head>
  <body>
    <script type="text/javascript">
      function BinaryTree() {
        var Node = function(key) {
          this.key = key;
          this.left = null;
          this.right = null;
        }

        var root = null;
        
        var insertNode = function (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 = function (key) {
          var NewNode = new Node(key)
          if(root === null) {
            root = NewNode
          } else {
            insertNode(root, NewNode);
          }
        };

        var preOrderTraverseNode = function (node,callback) {
          if(node !== null) {
            callback(node.key);
            preOrderTraverseNode(node.left,callback);
            preOrderTraverseNode(node.right,callback)
          }
        }

        this.preOrderTraverse = function (callback) {
          preOrderTraverseNode(root, callback)
        }
      }

      var nodes = [8,3,10,1,6,14,4,7,13];
      var binaryTree = new BinaryTree();
      nodes.forEach(function(key){
        binaryTree.insert(key);
      })

      var callback = function (key) {
        console.log(key);
      }

      binaryTree.preOrderTraverse(callback);
    </script>
  </body>
</html>

后序遍历

原理：判断当前节点是否有左子节点，有的话，先遍历整个的左子树，再遍历整个右子树，最后输出当前节点（用于操作系统和文件系统中）

代码实现：

<!DOCTYPE html>
<html>
  <head>
    <title>binaryTree</title>
  </head>
  <body>
    <script type="text/javascript">
      function BinaryTree() {
        var Node = function(key) {
          this.key = key;
          this.left = null;
          this.right = null;
        }

        var root = null;
        
        var insertNode = function (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 = function (key) {
          var NewNode = new Node(key)
          if(root === null) {
            root = NewNode
          } else {
            insertNode(root, NewNode);
          }
        };

        var postOrderTraverseNode = function (node,callback) {
          if(node !== null) {
            postOrderTraverseNode(node.left,callback);
            postOrderTraverseNode(node.right,callback);
            callback(node.key);
          }
        }

        this.postOrderTraverse = function (callback) {
          postOrderTraverseNode(root, callback)
        }
      }

      var nodes = [8,3,10,1,6,14,4,7,13];
      var binaryTree = new BinaryTree();
      nodes.forEach(function(key){
        binaryTree.insert(key);
      })

      var callback = function (key) {
        console.log(key);
      }

      binaryTree.postOrderTraverse(callback);
    </script>
  </body>
</html>

二叉树节点查找

二叉树的节点查找分为三种：

  1. 查找二叉树节点的最小值
  2. 查找二叉树节点的最大值
  3. 给定一个值，判断二叉树节点中是否存在

查找二叉树节点的最小值

先判断当前节点是否有左孩子，然后进入节点3，判断现在的节点3是否有左孩子，然后有进入节点1，判断节点1是否有左孩子，没有，所有二叉树节点的最小值是节点1

<!DOCTYPE html>
<html>
  <head>
    <title>binaryTree</title>
  </head>
  <body>
    <script type="text/javascript">
      function BinaryTree() {
        var Node = function(key) {
          this.key = key;
          this.left = null;
          this.right = null;
        }

        var root = null;
        
        var insertNode = function (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 = function (key) {
          var NewNode = new Node(key)
          if(root === null) {
            root = NewNode
          } else {
            insertNode(root, NewNode);
          }
        };

        var minNode = function (node) {
          if (node) {
            while (node && node.left !== null) {
              node = node.left; 
            }
            return node.key
          }
          return null;
        }

        this.min = function () {
          return minNode(root)
        }
      }

      var nodes = [8,3,10,1,6,14,4,7,13];
      var binaryTree = new BinaryTree();
      nodes.forEach(function(key){
        binaryTree.insert(key);
      })

      var callback = function (key) {
        console.log(key);
      }
      console.log('min node is:' + binaryTree.min());

    </script>
  </body>
</html>

查找二叉树节点的最大值

先判断当前节点是否有右孩子，然后进入节点10，判断现在的节点10是否有右孩子，然后有进入节点14，判断节点14是否有右孩子，没有，所有二叉树节点的最大值是节点14

<!DOCTYPE html>
<html>
  <head>
    <title>binaryTree</title>
  </head>
  <body>
    <script type="text/javascript">
      function BinaryTree() {
        var Node = function(key) {
          this.key = key;
          this.left = null;
          this.right = null;
        }

        var root = null;
        
        var insertNode = function (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 = function (key) {
          var NewNode = new Node(key)
          if(root === null) {
            root = NewNode
          } else {
            insertNode(root, NewNode);
          }
        };

        var maxNode = function (node) {
          if (node) {
            while (node && node.right !== null) {
              node = node.right; 
            }
            return node.key
          }
          return null;
        }

        this.max = function () {
          return maxNode(root)
        }
      }

      var nodes = [8,3,10,1,6,14,4,7,13];
      var binaryTree = new BinaryTree();
      nodes.forEach(function(key){
        binaryTree.insert(key);
      })

      var callback = function (key) {
        console.log(key);
      }
      console.log('max node is:' + binaryTree.max());

    </script>
  </body>
</html>

给定一个值，判断二叉树节点中是否存在

假如给定的值是7，然后先判断与当前节点8的大小，比当前节点小就进入当前节点的左子树，进入节点3，判断节点3大小，然后进入节点3的右子树，进入节点6，判断节点6大小，然后进入节点6的右子树

<!DOCTYPE html>
<html>
  <head>
    <title>binaryTree</title>
  </head>
  <body>
    <script type="text/javascript">
      function BinaryTree() {
        var Node = function(key) {
          this.key = key;
          this.left = null;
          this.right = null;
        }

        var root = null;
        
        var insertNode = function (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 = function (key) {
          var NewNode = new Node(key)
          if(root === null) {
            root = NewNode
          } else {
            insertNode(root, NewNode);
          }
        };

        var searchNode = function (node,key) {
          if (node === null) {
            return false
          }
          if( key < node.key) {
            return searchNode(node.left, key)
          } else if(key > node.key) {
            return searchNode(node.right, key)
          } else {
            return true
          }
        }

        this.search = function (key) {
          return searchNode(root, key)
        }
      }

      var nodes = [8,3,10,1,6,14,4,7,13];
      var binaryTree = new BinaryTree();
      nodes.forEach(function(key){
        binaryTree.insert(key);
      })

      var callback = function (key) {
        console.log(key);
      }
      console.log(binaryTree.search(7) ? 'key 7 is found' : 'key 7 is not found');
      console.log(binaryTree.search(9) ? 'key 9 is found' : 'key 9 is not found');
    </script>
  </body>
</html>

二叉树叶子节点的删除原理及实现

二叉树节点的删除也是可以分为几种情况:

  • 被删除节点为叶子节点；
  • 被删除节点仅有一个子节点（子树）；
  • 被删除节点有两个子节点（子树）

被删除节点为叶子节点

思路：将该叶子节点的父节点指向的子节点的引用值设为空

被删除节点仅有一个子树

思路：将该节点的父节点指向该节点的引用改成指向该节点的子节点。

被删除节点有两个子树

思路：处理这种情况有两种方法：

  • 从待删除节点的左子树找节点值最大的节点A，替换待删除节点，并删除节点A；
  • 从待删除节点的右子树找节点值最小的节点A，替换待删除节点，并删除节点A。

PS：我们这里选择第二种方法。
以下图的二叉树为例，删除节点3。

<!DOCTYPE html>
<html>
  <head>
    <title>binaryTree</title>
  </head>
  <body>
    <script type="text/javascript">
      function BinaryTree() {
        var Node = function(key) {
          this.key = key;
          this.left = null;
          this.right = null;
        }

        var root = null;
        
        var insertNode = function (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 = function (key) {
          var NewNode = new Node(key)
          if(root === null) {
            root = NewNode
          } else {
            insertNode(root, NewNode);
          }
        };
        var findMinNode = function(node) {
          if(node) {
            while (node && node.left !== null) {
              node = node.left;
            }
            return node
          }
        }
        var removeNode = function (node,key) {
          if (node === null) {
            return false
          }
          if( key < node.key) {
            node.left = removeNode(node.left, key)
            return node
          } else if(key > node.key) {
            node.right = removeNode(node.right, key)
            return node
          } else {
            // 没有子节点（子树）
            if(node.left === null && node.right === null) {
              node = null;
              return node
            }
            // 只有右子节点（子树）
            if(node.left === null) {
              node = node.right;
              return node;
            // 只有左子节点（子树）
            } else if (node.right === null) {
              node = node.left;
              return node;
            }
            // 有两个子节点（子树）
            var aux = findMinNode(node.right);
            node.key = aux.key;
            node.right = removeNode(node.right, aux.key);
            return node;
          }
        }

        this.remove = function (key) {
          return removeNode(root, key)
        }
      }

      var nodes = [8,3,10,1,6,14,4,7,13];
      var binaryTree = new BinaryTree();
      nodes.forEach(function(key){
        binaryTree.insert(key);
      })

      var callback = function (key) {
        console.log(key);
      }
      binaryTree.remove(3)
    </script>
  </body>
</html>

gitHub地址：排序二叉树的代码实现

不一于汝
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
JS实现的二叉树算法完整实例
10-20
主要介绍了JS实现的二叉树算法,结合完整实例形式分析了基于JS定义、创建二叉树及常用的各种遍历、访问二叉树操作技巧,需要的朋友可以参考下
JavaScript数据结构和算法之二叉树详解
10-24
主要介绍了JavaScript数据结构和算法之二叉树详解,本文讲解了二叉树的概念、二叉树的特点、二叉树节点的定义、查找最大和最小值等内容,需要的朋友可以参考下
JavaScript数据结构之二叉树的查找算法示例
10-20
主要介绍了JavaScript数据结构之二叉树的查找算法,结合具体实例形式分析了javascript针对二叉树节点最小值、最大值的相关查找操作实现技巧,需要的朋友可以参考下
JS实现二叉树算法
sinat_28979467的博客
05-19 1045
本文通过js来认识什么是二叉树、如何构建二叉树、二叉树有哪几种遍历算法及节点删除操作实现 什么是二叉树 二叉树是n个结点的有限集合，该集合或者为空集，或者由一个根结点和两颗互不相交的、分别称为根结点的左子树和右子树的二叉树组成。如下图1为二叉树： JS构建二叉树 约定右子树的节点值都大于左子树节点的值（也可以是左子树节点值大于右子树节点值）。数组第一个元素作为根节点的值、根据数组元素的顺序构建二...
js实现二叉树的遍历
程序媛的梦工厂
08-21 896
前序 递归 非递归 中序 递归 非递归 后序 递归 非递归
关于二叉树的算法（JavaScript）
fish_dream
06-28 846
关于二叉树的高频算法题
js实现二叉树常见算法操作
weixin_43601554的博客
08-04 555
1. 二叉树的中序遍历 leetcode94 方法一：递归 var inorderTraversal = function(root) { let result = []; let inorder = function(node){ node.left && inorderTraversal(node.left); result.push(node.val); node.right
使用JS实现二叉树相关算法
weixin_42192113的博客
07-13 361
1. 如何编译一个二叉树 思路： 创建一个队列，通过队列的进出实现对二叉树所有节点的遍历 实现代码如下: function traverseNode(q){ var queue = [] queue.push(q) while(queue.length != 0){ var node = queue.pop() console.log('value ==========> ', node.val) if(node.left) queue.push(node.left) if(no
【JavaScript 算法】-- 神奇的二叉树
野生松
05-10 314
1、二叉树定义 二叉树是指满足以下要求的树： 它可以没有根结点，作为一棵空树存在 如果它不是空树，那么必须由根结点、左子树和右子树组成，且左右子树都是二叉树。 2、二叉树编码实现 在 JS 中，二叉树使用对象来定义。它的结构分为三块：数据域，左指针、右指针 // 二叉树结点构造函数 function TreeNode(val) { this.val = val; this.left = this.right = null; } 3、二叉树遍历 按照顺序规则的不同，遍历方式
javascript数据结构及实现二叉树算法
韩潇的博客
09-08 2856
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
JS二叉树的简单实现方法示例
12-09
本文实例讲述了JS二叉树的简单实现方法。分享给大家供大家参考，具体如下： 今天学习了一下 二叉树的实现，在此记录一下 简单的二叉树实现，并且实现升序和降序排序输出 function Node(data , left,right){ this.data = data; this.left = left; this.right = right; this.show = show; function show(){ return this.data; } }; function Bst(){ this.root = null; this.insert = i
javascript实现二叉树的代码
10-19
在本文中，我们将深入探讨如何使用JavaScript实现二叉搜索树（Binary Search Tree，简称BST）。二叉搜索树是一种特殊的二叉树，它的每个节点都遵循特定的规则：左子节点的值小于父节点的值，而右子节点的值大于或...
javascript实现二叉树遍历的代码
10-19
在本文中，我们将深入探讨JavaScript实现二叉树遍历的方法。首先，二叉树是一种数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。我们通过创建一个`Node`构造函数和一个`BST`（二叉搜索树）...
javascript 二叉树部分功能实现
09-05
javascript 二叉树功能实现。（功能有插值、查询、最小值、最大值、删除、清除、前序遍历、中序遍历、后序遍历）
javascript算法系列——树：二叉树和二叉查找树
weixin_43867717的博客
03-17 1451
二叉树的基本术语 结点之间的关系 若一个结点有子树，那么该结点称为子树根的双亲，子树的根称为该结点的孩子 有相同双亲的结点互为兄弟 一个结点的所有子树上的任何结点都是该结点的后裔 从根结点到某个结点的路径上的所有结点都是该结点的祖先 结点层：根结点的层定义为第一层，根的孩子为第二层，依此类推 树的深度：树中最大的结点层 结点的度：结点拥有的子树的个数 树的度： 树中最大的结点度 叶子结点：也叫终端结点，是度为 0 的结点 分枝结点：度不为0的结点 二叉查找树 二叉查找树是一种 特殊的二叉树，相对较
javascript二叉树（二叉搜索树）
qq_43526925的博客
08-17 376
树 概念： 拥有相同的父节点的节点，互称为兄弟节点 节点的深度：从根节点到该节点所经历的边的个数 节点的高度：节点到叶节点的最长路径 树的高度：根节点的高度 二叉树 二叉树即最多仅有两个子节点的树 二叉树的存储方法： 链式存储（即用链表存储） 线性存储（即用数组存储） 二叉树常见类型 完全二叉树：如果对满二叉树的结点进行编号, 约定编号从根结点起, 自上而下, 自左而右。则深度为k的, 有n个结点的二叉树, 当且仅当其每一个结点都与深度为k的满二叉树中编号从1至n的结点一一对应时, 称之为完全二叉
js数据结构和算法（三）二叉树
01-04 276
二叉树的概念 二叉树（Binary Tree）是n（n>=0）个结点的有限集合，该集合或者为空集（空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。 二叉树的特点 每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点。二叉树中每一个节点都是一个对象，每一个数据节点都有三个指针，分别是指向父母、左孩子和右孩子的指针。每一个节点都是通过指针相互连接
JavaScript实现二叉树算法
weixin_30292843的博客
06-10 123
二叉树的遍历方式 　　分别为中序遍历（左子树->当前节点->右子树）、前序遍历（当前节点->左子树->右子树）、后序遍历（左子树->右子树->当前节点）。下面使用JavaScript语言实现二叉树的三种遍历算法。 　　首先构造一个排序二叉树（即满足左子节点比父节点小，右子节点比父节点大的二叉树），然后对其分别进行中序、前序、后序遍历。 排序二叉树结构图如下...
JavaScript实现排序二叉树（数据结构）
wenjiusui8083的博客
03-19 2239
被腾讯面试了2小时算法挂掉的前端不是好前端谁让前端JS那么火呢？SO 重新学习数据结构和算法吧！排序算法对前端来说非常重要！排序二叉树： 左子树小于根节点，右子树大于根节点，子树也满足这样的条件，这样的树叫做排序二叉树。所以JavaScript构建这样一个二叉树的过程如下：var BinaryTree = {     var Node = function(){ }//定义二叉树的节点Node  ...
给我一段使用js写的反转二叉树算法
最新发布
07-15
以下是使用 JavaScript 编写的反转二叉树（翻转二叉树）的算法示例代码： ```javascript function TreeNode(val, left, right) { this.val = val; this.left = left; this.right = right; } function ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值