数据结构(六)树JS实现

最新推荐文章于 2023-11-27 09:00:00 发布
最新推荐文章于 2023-11-27 09:00:00 发布
阅读量443 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33811654/article/details/107492378
版权

数据结构(六)树JS实现

树的特点

1.相关术语

  • 节点的度(Degree)：节点的子树个数个数
  • 树的度：树中所有节点里最大的度
  • 叶节点(Leaf)：度数为0的节点
  • 父节点(Parent)：有子树的节点，相对其子节点
  • 子节点(Child)：有父节点的节点，相对其父节点
  • 兄弟节点(Sibling)：具有相同父节点的子节点
  • 路径和路径长度：树从根节点到最远叶节点之间拥有的边数
  • 节点的层次(Level)：根节点在1层，其他热议节点的层数是其父节点的层数加一
  • 树的深度(Depth)：树中所有节点里最大层数就是这棵树的深度

2.优点

  • 树是数组和链表的折中方案，既有数组的查询速度，又有链表的插入和删除的速度

3.树的表示方式

  • 普通的表示方法

在这里插入图片描述

  • 左儿子-右兄弟表示法

在这里插入图片描述

二叉树

树中每个节点最多有2个的子节点

二叉树的五种形态

在这里插入图片描述

二叉树特性

在这里插入图片描述

完美二叉树

在这里插入图片描述

完全二叉树

在这里插入图片描述

二叉树的存储方式

  • 数组

    从上到下，从左到右

在这里插入图片描述

*链表

每个节点都包含左节点和右节点的引用

在这里插入图片描述

二叉搜索树 (Binary Search Tree)

性质
  • 非空左子树所有键值小于根节点的键值
  • 非空右子树所有键值大于根节点的键值
  • 左，右子树本身也是二叉搜索树
  • 相对较小的值总是保存在左节点上，相对较大的值总是保存在右节点上
  • 查询效率较高
插入
  • 插入操作可以分解成每个节点与传入节点键值进行比较，大于传入键值则向左子节点查询，反之向右查询直到节点键值为null，可以利用递归方式
 insert(key) {
          //1.创建一个node对象
          let newNode = new this.Node(key)
          //2.判断root是否为空
          if (this.root == null) {
            this.root = newNode
          } else {
            this.insertNode(this.root, newNode)
          }
        }

        insertNode(node, newNode) {
          if (node.key > newNode.key) {
            //向左插入
            if (node.left == null) {
              node.left = newNode
            } else {
              this.insertNode(node.left, newNode)
            }
          } else {
            //向右插入
            if (node.right == null) {
              node.right = newNode
            } else {
              this.insertNode(node.right, newNode)
            }
          }
        }
遍历
  • 先序遍历: 递归函数每次先处理节点键值，再查询左节点查询，最后查询右节点
 preOrder(handler) {
          this.preOrderNode(this.root, handler)
        }

        preOrderNode(node, handler) {
          if (node !== null) {
            handler(node.key)

            this.preOrderNode(node.left, handler)

            this.preOrderNode(node.right, handler)
          }
        }
  • 中序遍历：递归函数 = left-> node.key -> right
 middleOrder(handlder) {
          this.middleOrderNode(this.root, handlder)
        }

        middleOrderNode(node, handlder) {
          if (node !== null) {
            this.middleOrderNode(node.left, handlder)

            handlder(node.key)

            this.middleOrderNode(node.right, handlder)
          }
        }

  • 后序遍历：left-> right -> node.key

     postOrder(handlder) {
          this.postOrderNode(this.root, handlder)
        }

        postOrderNode(node, handlder) {
          if (node !== null) {
            this.postOrderNode(node.left, handlder)

            this.postOrderNode(node.right, handlder)

            handlder(node.key)
          }
        }
最值查找
  • 最大值
max(root = this.root) {
          //扩展根据传入节点查找其下最值，默认等于根节点，允许传入节点，返回相关数组
          // let root = this.root
          while (root.right !== null) {
            root = root.right
          }
          return [root, root.key] //0-> root,1->key
        }
  • 最小值
min(root = this.root) {
          // let root = this.root
          while (root.left !== null) {
            root = root.left
          }
          return [root, root.key] //0-> root,1->key
        }
删除

分三种情况

    1. 删除的是叶子节点
    1. 删除的节点有一个子节点
  • ​ 3.删除的节点拥有超过一个子节点
1.查找要删除的点
/*
*搜索函数根据传入的键值找出对应节点
*return 数组node[] 0-> parent, 1->child, 2->isLeftChild
*/
searchNode(key) {
          let node = [null, this.root, false] //0-> parent, 1->child, 2->isLeftChild
          let root = this.root
          while (node[1] !== null) {
            if (node[1].key > key) {
              node[0] = node[1]
              node[2] = true
              node[1] = node[1].left
            } else if (node[1].key < key) {
              node[0] = node[1]
              node[2] = false
              node[1] = node[1].right
            } else if (node[1].key == key) {
              return node
            }
          }
          return false
        }

let nodeArray = this.searchNode(key)
2.判断节点情况
remove(key) {
          //1.查询要删除的节点
          let nodeArray = this.searchNode(key)
          if (nodeArray == false) {
            return null
          } else if (nodeArray[1].left == null && nodeArray[1].right == null) {
            //1.删除叶子节点
            if (nodeArray[2] == true) {
              nodeArray[0].left = null
            } else {
              nodeArray[0].right = null
            }
          } else if (nodeArray[1].left == null || nodeArray[1].right == null) {
            //2.删除的节点只有一个子节点
            if (nodeArray[2] == true) {
              if (nodeArray[1].left == null) {
                nodeArray[0].left = nodeArray[1].right
              } else {
                nodeArray[0].left = nodeArray[1].left
              }
            } else {
              if (nodeArray[1].left == null) {
                nodeArray[0].right = nodeArray[1].right
              } else {
                nodeArray[0].right = nodeArray[1].left
              }
            }
          } else {
            //3.删除的节点有超过一个子节点,左子树找最大，右子树找最小 。默认查左子树

            let max = this.getBest(nodeArray[1].left, true)[1] //找出其最大的节点
            let maxNode = this.searchNode(max) //找出最大节点的父节点

            if (nodeArray[0] == null) {
              //更改节点指向的顺序很重要
              this.root = maxNode[1]
              maxNode[0].right = maxNode[1].left
              maxNode[1].right = nodeArray[1].right
              maxNode[1].left = nodeArray[1].left
              return true
            }

            if (nodeArray[2] == true) {
              //当要删除的节点属于左节点
              nodeArray[0].left = maxNode[1]
              maxNode[1].left =
                nodeArray[1].left.key == maxNode[1].key
                  ? null
                  : nodeArray[1].left //判断
              maxNode[1].right = nodeArray[1].right
              maxNode[0].right = maxNode[1].left
            } else {
              nodeArray[0].right = maxNode[1]
              maxNode[1].left =
                nodeArray[1].left.key == maxNode[1].key
                  ? null
                  : nodeArray[1].left
              maxNode[1].right = nodeArray[1].right
              maxNode[0].right = maxNode[1].left
            }
          }
        }

getBest(node, isLeft) {
    //根据节点返回最大或最小节点
          if (isLeft) {
            return this.max(node)
          } else {
            return this.min(node)
          }
        }

二叉平衡树

  • 需求：二叉搜索树在插入一系列键值连续的节点时，会造成二叉树左右分布不均匀和深度增加，使查询等操作的时间复杂度下降到O(N)，
  • 解决方案
AVL树
红黑树

通过规定并保持一些性质保证二叉树的分布均匀

特点
  • 1.节点是红色或者黑色
  • 2.根节点是黑色
  • 3.每个叶子节点都是黑色(NIL)
  • 4.每个红色节点都有两个黑色子节点(从叶子节点到根的路径上不能拥有两个连续的红色节点)
  • 5.任一节点到其各个叶子节点之间的黑色节点的数目相同
  • 在根到所有叶子节点的路径中，最长路径的长度不能是最短路径的两倍
  • 根据性质4任意路径不能有连续的两个红色节点
  • 根据性质5所有路径都具有相同数目的黑色节点，推出特点6
在插入一个新的节点时，如何保持红黑树的特点

在这里插入图片描述

  • 变色 – 左旋转 – 右旋转
  • 旋转：

在这里插入图片描述

插入操作

设要插入的节点为N(node)，父节点P，祖父节点G，叔叔节点U

  • 情况一：N位于树的根上没有父节点

    直接将那个红色换黑色即可

  • 情况二：N的父节点P是黑色

    不变

  • 情况三：P->红，U->红，G->黑

    红红黑 ->黑黑红

在这里插入图片描述

  • 情况四：P->红，U->黑，N为左孩子

    P->黑，G->红，以G为根右旋转

在这里插入图片描述

  • 情况五：P->红，U->黑，N为右孩子

    以P为根进行左旋转 -> N变黑色 ->G变红色 ->以G为根进行右旋转

在这里插入图片描述

实例

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

IsYouGeGe
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaScript实现树结构（一）
Ben_Simons
08-14 585
JavaScript实现树结构（一） 一、树结构简介 1.1.简单了解树结构 什么是树？ 真实的树： 树的特点： 树一般都有一个根，连接着根的是树干； 树干会发生分叉，形成许多树枝，树枝会继续分化成更小的树枝； 树枝的最后是叶子； 现实生活中很多结构都是树的抽象，模拟的树结构相当于旋转180°的树。 树结构对比于数组/链表/哈希表有哪些优势呢： 数组： 优点：可以通过下标值访问，效率高； 缺点：查找数据时需要先对数据进行排序，生成有序数组，才能提高查找效率；...
获取树的深度
liu20121787的博客
06-06 1419
注：题目来源于 Java资讯库 ，代码通过网上搜集整理而来 // 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点 （含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 public class Tree { public int getTreeDepth(TreeNode treeNode){ if(treeNode ==null){ eturn 0; } int left = getTreeDepth(treeNode.left);
JS树结构操作:查找、遍历、筛选、树结构和列表结构相互转换
OUalen的博客
06-28 4359
JS树结构操作:查找、遍历、筛选、树结构和列表结构相互转换
【数据结构与算法】JavaScript实现树结构
最新发布
一个前端开发者
11-27 1264
什么是树？树一般都有一个根，连接着根的是树干；树干会发生分叉，形成许多树枝，树枝会继续分化成更小的树枝；树枝的最后是叶子；现实生活中很多结构都是树的抽象，模拟的树结构相当于旋转180°的树。树结构对比于数组/链表/哈希表有哪些优势呢：优点：可以通过下标值访问，效率高；缺点：查找数据时需要先对数据进行排序，生成有序数组，才能提高查找效率；并且在插入和删除元素时，需要大量的位移操作；优点：数据的插入和删除操作效率都很高；查找效率低，需要从头开始依次查找，直到找到目标数据为止；
js实现树形结构，功能非常强大，而调用又非常简单
12-01
一个JS实现的树，功能非常强大，而调用又非常简单 刚刚在一个公司项目中用到，包括详细的帮助文档和函数说明，还有例子程序，一看就懂，希望对大家有所帮助
使用jsTree实现js树形结构
06-07
例程可正常使用，非常的简单，基本上学过几天代码的人都能够正常使用。采用纯js编写，不复杂
javascript数据结构之二叉搜索树实现方法
10-23
主要介绍了javascript数据结构之二叉搜索树实现方法,较为详细的分析了二叉搜索树的概念、原理与JavaScript实现二叉搜索树的方法,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下
js实现无限层级树形数据结构(创新算法)
11-20
把一个线性数组转成树形数组，在网上查了很多文章，觉得他们写的太复杂了，于是自己写了一个，在折腾了一下午终于把它写出来啦（激动.gif），用两个filter过滤器就搞定了，代码简洁明了，数据结构小白都能看懂。...
数据结构源码JS实现.zip
03-12
1.tree 2.queue 3.stack 4.hash 5.linkedList 欢迎大家关注，私戳免费可以获取
JS数据结构与算法.pdf
11-01
* 本书提供了详细的知识点和实践应用，帮助读者了解 JavaScript 数据结构和算法的实现和应用。 本书提供了详细的知识点和实践应用，帮助读者了解 JavaScript 数据结构和算法的实现和应用。此外，本书还提供了实践...
js实现树形图
09-03
简单易用的js实现树形图，适于通用目录树。现成源码，直接使用。
JSTree(js写的树形菜单，支持加载10000节点以上)
12-23
js树形菜单组件，主要解决大数据加载节点卡死问题。
JS树学习
05-27
Dtree相关 博文链接：https://cdfive20.iteye.com/blog/605319
js 实现链表和树的结构
lulula的博客
10-28 3575
最近在学习es6 所以代码主要使用了es6的一些东西 链表的设计 我们设计链表包含两个类，一个是 Node 类用来表示节点，另一个事 LinkedList 类提供插入节点、删除节点等一些操作。 /** * 一般的语言实现链表都需要指针来实现 * 而js的引用类型本来就是按值引用的 * 变量中保存的实质上是一个指向其对应对象的一个...
JS数据结构:树
Preshine
08-01 4885
树(tree)形结构是一种重要的非线性结构，依据分支关系定义的层次结构，在这种结构中，每个元素至多只有一个前趋，但可以有多个后继。 树的定义：树(Tree)是n(n 大于等于0)个节点的有限集合T，当n=0时称为空树，否则，称为非空树。 常用的树形表示方法有： 1。集合嵌套法2.凹入表表示法         3.广义表表示法 (A(B(E(k),F),C(G),D(H,I,J))  ...
js实现树级递归，通过js生成tree树形菜单(递归算法)
热门推荐
u013373006的博客
08-27 8万+
1、效果图 需求：首先这是一个数据集—js的类型，我们需要把生成一个tree形式的对象 : var data = [ { id: 1, name: "办公管理", pid: 0 }, { id: 2, name: "请假申请", pid: 1 }, { id: 3, name: "出差申请", pid: 1 }, { id: 4, name: "请假记录", pid: 2 }, { id...
js实现数据结构--树
阳光下的冷静的博客
11-29 1148
什么是树？ 树是一种分层数据的抽象模型。现实生活中最常见的树的例子就是家谱，或是公司的组织架构。 树的结构图：如下图 树的相关术语： 一棵树包含一系列存在父子关系的节点。每个节点都有一个父节点(除了顶部的第一个节点)以及零个或多个子节点.下面介绍几个常见的树的术语。 根节点：位于树顶部的节点，它没有父节点 内部节点：至少有一个子节点的节点 外部节点：没有子节点的节点，也称为叶节点...
JavaScript 树实现
oLaoJiang1的博客
08-14 404
/* 节点 */ function Node(data, left = null, right = null) { this.data = data; this.left = left; this.right = right; } /* 创建树 */ function BST(){ this.root = null; this.add ...
leetcode----给定一棵任意二叉树，填充所有节点的next指针，指向它右兄弟节点。如果没有右兄弟节点，则应该将next指针设置为NULL。
sunnnnh的博客
07-14 775
题目描述 继续思考"Populating Next Right Pointers in Each Node".这道题 给定一个二叉树 struct TreeLinkNode {↵ TreeLinkNode *left;↵ TreeLinkNode *right;↵ TreeLinkNode *next;↵ } 填充所有节点的next指针，指向它右兄弟节点。如果没有右兄弟节点，则应该将next指针设置为NULL。 初始时，所有的next指针都为NULL。
js 树形数据结构查找
05-18
在 JavaScript 中，我们可以使用对象或数组来实现树形数据结构，并且可以使用递归来查找树中的节点。以下是一个示例： 假设我们有以下的树形数据结构： ```javascript const tree = { value: 'A', children: [ { value: 'B', children: [ { value: 'D', }, { value: 'E', }, ], }, { value: 'C', children: [ { value: 'F', }, ], }, ], }; ``` 我们要查找值为 `'F'` 的节点，可以使用以下代码： ```javascript function findNode(tree, value) { if (tree.value === value) { return tree; } if (!tree.children) { return null; } for (let i = 0; i < tree.children.length; i++) { const node = findNode(tree.children[i], value); if (node) { return node; } } return null; } const node = findNode(tree, 'F'); console.log(node); // { value: 'F' } ``` 在这个示例中，我们定义了一个 `findNode` 函数，该函数接受两个参数：`tree` 表示树形数据结构的根节点，`value` 表示要查找的节点的值。 首先，我们检查当前节点是否是要查找的节点，如果是，则返回该节点。然后，我们检查当前节点是否有子节点，如果没有，则返回 `null`。否则，我们遍历每个子节点，递归调用 `findNode` 函数，在子节点中查找要查找的节点。如果找到了节点，则返回该节点。 最后，如果在整棵树中找不到要查找的节点，则返回 `null`。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值