一、树
（1）树的定义:
-
树（Tree）: n（n≥0）个结点构成的有限集合
-
当n=0时，称为空树
-
对于任一棵非空树（n> 0），它具备以下性质：
-
树中有一个称为“根（Root）”的特殊结点，用 root 表示；
-
其余结点可分为m(m>0)个互不相交的有限集T1，T2，... ，Tm，其中每个集合本身又是一棵树，称为原来树的“子树（SubTree）”
-
注意:
子树之间不可以相交
除了根结点外，每个结点有且仅有一个父结点
一棵N个结点的树有N-1条边
（2）树的结构
（3）树的优点：
树结构、数组和链表的对比
-
数组:
-
优点:
-
数组的主要优点是根据下标值访问效率会很高.
-
根据元素来查找对应的位置时先对数组进行排序, 再进行二分查找
-
-
缺点:
-
需要先对数组进行排序, 生成有序数组, 才能提高查找效率.
-
另外数组在插入和删除数据时, 需要有大量的位移操作(插入到首位或者中间位置的时候), 效率很低.
-
-
-
链表:
-
优点:
-
链表的插入和删除操作效率都很高.
-
-
缺点:
-
查找效率很低, 需要从头开始依次访问链表中的每个数据项, 直到找到.
-
而且即使插入和删除操作效率很高, 但是如果要插入和删除中间位置的数据, 还是需要重头先找到对应的数据.
-
-
-
树结构:
-
不能说树结构比其他结构都要好, 因为每种数据结构都有自己特定的应用场景.
-
但是树确实也综合了上面的数据结构的优点(当然优点不足于盖过其他数据结构), 并且也弥补了上面数据结构的缺点.
-
而且为了模拟某些场景,使用树结构会更加方便. 比如文件的目录结构.
-
（4）树的术语:
结点的度（Degree）：结点的子树个数
树的度：树的所有结点中最大的度数. (树的度通常为结点的个数N-1)
叶结点（Leaf）：度为0的结点. (也称为叶子结点)
父结点（Parent）：有子树的结点是其子树的根结点的父结点
子结点（Child）：若A结点是B结点的父结点，则称B结点是A结点的子结点(也称孩子结点)
兄弟结点（Sibling）：具有同一父结点的各结点彼此是兄弟结点
路径和路径长度：从结点n1到nk的路径为一个结点序列n1 , n2,… , nk, ni是 ni+1的父结点，路径所包含边的个数为路径的长度
结点的层次（Level）：规定根结点在1层，其它任一结点的层数是其父结点的层数加1
树的深度（Depth）：树中所有结点中的最大层次是这棵树的深度
二、二叉树
1）概念
- 树中每个节点最多只能有两个子节点, 这样的树就成为"二叉树"
二叉树的定义
-
二叉树可以为空, 即没有结点
-
不为空时它是由根结点和称为其左子树TL和右子树TR的两个不相交的二叉树组成
二叉树的五种形态
注：c和d是不同的二叉树, 因为二叉树有左右之分
2）二叉树的特性
-
一个二叉树第 i 层的最大结点数为：2^(i-1), i >= 1
-
深度为k的二叉树有最大结点总数为： 2^k - 1, k >= 1
-
对任何非空二叉树 T，若n0表示叶结点的个数、n2是度为2的非叶结点个数，那么两者满足关系n0 = n2 + 1
3）特殊的二叉树
-
完美二叉树(Perfect Binary Tree) , 也称为满二叉树(Full Binary Tree）
-
在二叉树中, 除了最下一层的叶结点外, 每层节点都有2个子结点, 就构成了满二叉树
-
-
完全二叉树(Complete Binary Tree)
-
除二叉树最后一层外, 其他各层的节点数都达到最大个数
-
且最后一层从左向右的叶结点连续存在, 只缺右侧若干节点
-
完美二叉树是特殊的完全二叉树
-
-
下面不是完全二叉树, 因为D节点还没有右结点, 但是E节点就有了左右节点
4）二叉树的存储
-
二叉树的存储常见的方式是使用链表存储.
-
链表存储:
-
每个结点封装成一个Node, Node中包含存储的数据, 左结点的引用, 右结点的引用.
-
三、二叉搜索树
1）概念
-
二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树
-
二叉搜索树是一颗二叉树, 可以为空
-
如果不为空，满足以下性质：
-
非空左子树的所有键值小于其根结点的键值
-
非空右子树的所有键值大于其根结点的键值
-
左、右子树本身也都是二叉搜索树
-
2）特点
-
二叉搜索树的特点就是相对较小的值总是保存在左结点上, 相对较大的值总是保存在右结点上
-
查找效率非常高, 这也是二叉搜索树中, 搜索的来源
四、程序实现二叉搜索树
1）创建二叉搜索树类
//节点类
class Node {
constructor(data) {
this.left = null
this.data = data
this.right = null
}
}
//二叉搜索树类
class BST {
constructor() {
this.root = null
}
}2）二叉搜索树的操作
二叉搜索树常见的操作：
insert(key)：向树中插入一个新的键
search(key)：在树中查找一个键，如果结点存在，则返回true；如果不存在，则返回false
preOrderTraverse：通过先序遍历方式遍历所有结点
inOrderTraverse：通过中序遍历方式遍历所有结点
postOrderTraverse：通过后序遍历方式遍历所有结点
min：返回树中最小的值/键
max：返回树中最大的值/键
remove(key)：从树中移除某个键
（1） 向树中插入数据
insert(ele) {
//创建新节点
let newnode = new Node(ele)
if (this.root == null) {
//空树
this.root = newnode
} else {
this.insertNode(this.root, newnode)
}
}
insertNode(root, newnode) {
if (newnode.data < root.data) { //放左边
if (root.left == null) {
root.left = newnode
} else {
this.insertNode(root.left, newnode)
}
}else{ //放右边
if (root.right == null) {
root.right = newnode
} else {
this.insertNode(root.right, newnode)
}
}
}图示：
（2）遍历二叉搜索树
1)preOrderTraverse：通过先序遍历方式遍历所有结点
遍历过程：
- 访问根结点
- 先序遍历其左子树
- 先序遍历其右子树
preOrderTraversal(){
this.preOrderTraversalNode(this.root)
}
preOrderTraversalNode(root){
if(root!=null){
//1.根
console.log(root.data)
//2.前序遍历左子树
this.preOrderTraversalNode(root.left)
//3.前序遍历右子树
this.preOrderTraversalNode(root.right)
}
} 2）inOrderTraverse：通过中序遍历方式遍历所有结点
遍历过程:
中序遍历其左子树
访问根结点
中序遍历其右子树
inOrderTraversal(){
this.inOrderTraversalNode(this.root)
}
inOrderTraversalNode(root){
if(root!=null){
//1.中序遍历左子树
this.inOrderTraversalNode(root.left)
//2.根
console.log(root.data)
//3.中序遍历右子树
this.inOrderTraversalNode(root.right)
}
} 3）postOrderTraverse：通过后序遍历方式遍历所有结点
遍历过程：
后序遍历其左子树
后序遍历其右子树
访问根结点
postOrderTraversal(){
this.postOrderTraversalNode(this.root)
}
postOrderTraversalNode(root){
if(root!=null){
//1.后序遍历左子树
this.postOrderTraversalNode(root.left)
//2.中序遍历右子树
this.postOrderTraversalNode(root.right)
//3.根
console.log(root.data)
}
}(3)返回树中最小的值/键
getMin(){
if(this.root==null){
return
}else{
let current=this.root
while(current.left!=null){
current=current.left
}
return current.data
}
}(4)返回树中最大的值/键
getMax(){
if(this.root==null){
return
}else{
let current=this.root
while(current.right!=null){
current=current.right
}
return current.data
}
}(5)从树中移除某个键
remove(ele) {
if (this.root == null) return
let current = this.root,
parent, isLeftChild
//找到删除节点及其父节点，判断是否为左子节点
while (ele != current.data) {
if (ele < current.data) {
//左边找
parent = current
current = current.left
isLeftChild = true
} else {
parent = current
current = current.right
isLeftChild = false
}
}
console.log(`当前删除的节点是${current.data},删除元素的父节点是${parent.data},是左子节点吗？${isLeftChild}`)
let delNode = current
//1.删除叶节点 （左右子树都为空）
if (delNode.left == null && delNode.right == null) {
if (delNode == this.root) {
this.root = null
} else {
if (isLeftChild) {
//左子节点
parent.left = null
} else {
//右子节点
parent.right = null
}
}
} else if (delNode.left != null && delNode.right == null) {
//2.删除只有一个左子节点的节点
if (delNode == this.root) {
this.root = this.root.left
} else {
if (isLeftChild) {
parent.left = delNode.left
} else {
parent.right = delNode.left
}
}
} else if (delNode.left = null && delNode.right !== null) {
//3.删除只有一个右子节点的节点
if (delNode == this.root) {
this.root = this.root.right
} else {
if (isLeftChild) {
parent.left = delNode.right
} else {
parent.right = delNode.right
}
}
} else {
//4.删除有左右两个子节点的节点
//前驱：左子树中的最大值 后继：右子树中的最小值
let houji = this.gethouji(delNode)
if(delNode==this.root){
this.root=houji
}else{
if(isLeftChild){
parent.left=houji
}else{
parent.right=houji
}
}
houji.left=delNode.left
}
}
gethouji(delNode) {
let current = delNode.right //后继
let houjiparent = delNode
while (current.left != null) {
houjiparent = current
current = current.left
}
if(current!=delNode.right){ //当后继为删除节点的右节点
houjiparent.left = current.right
current.right=delNode.right
}
return current
}(6) 查找（搜索）元素
search(ele){
if(this.root==null) return
let current=this.root
while(current){
if(ele<current.data){
//左边找
current=current.left
}else if(ele>current.data){
//右边找
current=current.right
}else{
return true
}
}
return false
}
381
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
