一、树
(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
}