打印二叉搜索树的叶子结点_带你玩转二叉查找树

最新推荐文章于 2022-04-15 10:32:17 发布
最新推荐文章于 2022-04-15 10:32:17 发布
阅读量531 收藏
点赞数 1
文章标签： 打印二叉搜索树的叶子结点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42356475/article/details/112769653
版权

3693141fa0491bc8e31522fa67ba0059.png

通过之前文章，相信大家已经掌握了树这一重要的数据结构的基本概念以及很重要的二叉树。今天呢，我们就将在这个基础上，继续讲解非常非常常用的动态二叉树: 二叉查找树。

树的基础知识, 如果忘了，可以参考下前文:

且听风吟：我肝了三天，就是为了让你搞懂什么是树​zhuanlan.zhihu.com
6a6dfc32746d66ace8fb74fa9144dc63.png

二叉查找树是个什么东西呢? 别急，下面我们将通过常规手段和非常规手段来带你了解一下。

定义

何谓二叉查找树？一种常见的定义如下:

二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树，排序二叉树，是指一棵空树或者具有下列性质的二叉树:

  1. 所有子树上面的左节点的值都比根结点要小，右节点的值都比根结点要大
  2. 任意结点的左右子树也都是二叉查找树
  3. 通过中序遍历，将得到的是一个有序的数列

相信看了这个所谓的定义，大家一定是云里雾里，下面我们通过一些图来直观感受一下(啥也不说了,一切尽在图中)。

依据上面的定义，我们可以画出多种形态的树，如下示:

0e6cc4f591a7e7f22d61ad0a0f0c11b4.png

盯着图琢磨一会, 从上图不难看出:

  • 二叉查找树的特点是: 一直往左儿子往下找左儿子，可以找到最小的元素(元素1)，一直往右儿子找右儿子，可以找到最大的元素(元素8)， 【树的左尽头是最小, 右尽头是最大】。
  • 三个图的通过中序遍历后，最终有序序列都是[1,2,3,4,5,6,7,8]
  • 三个图元素是一样的，都满足二叉查找树的特性，但是形态差异很大
  • 不同图查找一个元素，花费的代价不一样。比如: 查找元素8，图A,B,C查找次数依次是3次，5次和8次。

通过二叉树排序树的特性，看起来，我们可以用它来实现元素排序，但实际情况下好多时候不会这样做。因为二叉查找树不保证是一个平衡的二叉树，最坏情况下二叉查找树会退化成一个链表，也就是所有节点都没有左子树或者没有右子树，树的层次太深导致排序性能太差，如上图C 。

使用二分查找，可以很快在一棵二叉查找树中找到我们需要的值。

图解操作

二叉查找树也有相应的插入、查找、删除、查询最大值最小值等操作，下面，我们会通过一个个图来直观的解释，并附带相应的代码实现。

完整代码实现:

https://github.com/yiye93/algo​github.com

^^代码不易，希望大家给个星鼓励下^^

插入

先上图:

9ceed7bdd44df7e4de51a9bbeb0e95e9.png

用白话文描述一下整体流程:

  • 如果添加元素时是棵空树，那么初始化根节点。
  • 然后添加的值和根节点比较，判断是要插入到根节点左子树还是右子树，还是不用插入(值相同)。
  • 当值比根节点小时，元素要插入到根节点的左子树中，当值比根节点大时，元素要插入到根节点的右子树中，相等时不插入，只更新次数。
  • 然后再分别对根节点的左子树和右子树进行递归操作即可。

我们先来用代码完成一棵二叉查找树的定义:

// 二叉查找树节点定义
type BinarySearchNode struct {
 Value int               //元素值
 Nums  int               // 值重复次数
 Left  *BinarySearchNode //左子树
 Right *BinarySearchNode //右子树
}

type BinarySearchTree struct {
 Root *BinarySearchNode //根节点
}

func NewBinarySearchTree() *BinarySearchTree {
 return &BinarySearchTree{}
}

一个节点代表一个元素，节点的Value值是用来进行二叉查找的关键，当Value值重复时，我们将值出现的次数Nums加1。

这里很关键的一点是: 存在相同的元素值。

插入代码实现:

package tree

import (
 "fmt"

 "github.com/yiye93/algo/queue"
)

// 插入操作
func (tree *BinarySearchTree) Insert(value int) {
 if tree.Root == nil {
  tree.Root = &BinarySearchNode{Value: value, Nums: 1}
  return
 }
 // 步骤1: 找到要插入值的父节点
 currentNode := tree.Root
 for currentNode != nil {
  // 小于子树根节点的值
  if value < currentNode.Value && currentNode.Left != nil {
   currentNode = currentNode.Left
   // 大于子树根节点的值
  } else if value > currentNode.Value && currentNode.Right != nil {
   currentNode = currentNode.Right
   // 等于子树根节点的值
  } else {
   break
  }
 }
 // 步骤2: 把插入值插入到步骤1中找到的父节点的左子树或者右子树或者只增加重复次数
 if value < currentNode.Value {
  currentNode.Left = &BinarySearchNode{Value: value, Nums: 1}
 } else if value > currentNode.Value {
  currentNode.Right = &BinarySearchNode{Value: value, Nums: 1}
 } else {
  currentNode.Nums += 1
 }
 return
}

// 二叉查找树打印
// 为了直观感受二叉查找树的构造结构,我们实现一个简单的打印功能
func (tree *BinarySearchTree) Print() {
 if tree.Root == nil {
  fmt.Printf("tree is empty!n")
  return
 }
 // 采用层次遍历
 // 此处搞了个容量限制...
 q := queue.NewQueueOnLinklist(10000)
 // 头元素入队
 q.EnQueue(tree.Root)
 // 队列非空
 for !q.IsEmpty() {
  n := q.DeQueue().(*BinarySearchNode)
  // 左子树非空,左子树乖乖入队
  if n.Left != nil {
   q.EnQueue(n.Left)
   fmt.Printf("[value/nums/leftNode] is [%v/%v/%v]n", n.Value, n.Nums, n.Left.Value)
  }
  // 右子树非空,左子树乖乖入队
  if n.Right != nil {
   q.EnQueue(n.Right)
   fmt.Printf("[value/nums/rightNode] is [%v/%v/%v]n", n.Value, n.Nums, n.Right.Value)
  }
  if n.Left == nil && n.Right == nil {
   fmt.Printf("[value/nums/isLeafNode] is [%v/%v]n", n.Value, n.Nums)
  }
 }
}

参照我们之前的流程图,我们可以实现插入部分操作如上示，并且采用了层次遍历实现了一个简单的打印功能，方便我们直观的看到插入的树结构是否跟设想一致。

下面我们看一下我们的测试代码:

  1. demo1
func TestBinarySearchTree1(t *testing.T) {
 // **测试二叉查找树结构如下**
 //            4
 //       3         7
 //    1         6     8
 //
 //      2     5
 tree := NewBinarySearchTree()
 fmt.Printf("test Insert...n")
 tree.Print()
 //插入元素
 insertElems := []int{4, 3, 7, 1, 6, 8, 2, 5}
 for _, elem := range insertElems {
  tree.Insert(elem)
 }
 tree.Insert(3)
 tree.Insert(8)
 tree.Insert(8)
 //插入元素后打印树的结构
 tree.Print()
}

测试结果:

97a9a26515714624b22802eb2bcd5400.png

2. demo2

func TestBinarySearchTree2(t *testing.T) {
 // **测试二叉查找树结构如下**
 //  1
 //     2
 //        3
 //           4
 //              5
 //                 6
 //                    7
 //                      8
 tree := NewBinarySearchTree()
 tree.Print()
 //插入元素
 insertElems := []int{1, 2, 3, 4, 5, 6, 7, 8}
 for _, elem := range insertElems {
  tree.Insert(elem)
 }
 tree.Insert(1)
 tree.Insert(7)
 tree.Insert(7)
 //插入元素后打印树的结构
 tree.Print()
}

测试结果:

58f3275f905041d58b9b5638056c914f.png

查找

查找元素表示从根节点开始查找元素。具体分为:

  • 如果根节点为空，就直接返回空值
  • 如果不为空，通过以左子树小于父节点，右子树大于父节点的特性为依据进行判断，然后不断遍历进行查找元素，直到找到目标的元素为止。

02931b74219d7b57b86dde554bdf8c50.png

代码实现:

// 二叉查找树的搜索
func (tree *BinarySearchTree) Search(value int) *BinarySearchNode {
 if tree.Root == nil {
  return nil
 }
 currentNode := tree.Root
 for currentNode != nil {
  // 小于子树根节点的值
  if value < currentNode.Value {
   currentNode = currentNode.Left
   // 大于子树根节点的值
  } else if value > currentNode.Value {
   currentNode = currentNode.Right
   // 找到该值
  } else {
   return currentNode
  }
 }
 return nil
}

demo测试:

func TestBinarySearchTree1(t *testing.T) {
 // **测试二叉查找树结构如下**
 //            4
 //       3         7
 //    1         6     8
 //
 //      2     5
 tree := NewBinarySearchTree()
 //fmt.Printf("test Insert...n")
 //tree.Print()
 //插入元素
 insertElems := []int{4, 3, 7, 1, 6, 8, 2, 5}
 for _, elem := range insertElems {
  tree.Insert(elem)
 }
 tree.Insert(3)
 tree.Insert(8)
 tree.Insert(8)
 //插入元素后打印树的结构
 //tree.Print()
 // 查找
 fmt.Printf("test Search...n")
 for i := 0; i <= 10; i++ {
   if tree.Search(i) == nil {
   fmt.Printf("search elem:%v not existn", i)
  } else {
   fmt.Printf("search elem:%v existn", i)
  }
 }
}

测试效果:

8f85eb4429af1adf0cb53960027b6468.png

查找最大值和最小值

查找最大值和最小值比较简单: 一直往左儿子往下找左儿子，可以找到最小的元素，一直往右儿子找右儿子，可以找到最大的元素。

4cd9a9edd8cb3f5b391cc2be9f866a6d.png

代码实现:

// 查询最小值
func (tree *BinarySearchTree) FindMin() *BinarySearchNode {
 if tree.Root == nil {
  return nil
 }
 currentNode := tree.Root
 // 一直往左子树遍历
 for currentNode != nil {
  if currentNode.Left != nil {
   currentNode = currentNode.Left
  } else {
   break
  }
 }
 return currentNode
}

// 查询最大值
func (tree *BinarySearchTree) FindMax() *BinarySearchNode {
 if tree.Root == nil {
  return nil
 }
 currentNode := tree.Root
 // 一直往右子树遍历
 for currentNode != nil {
  if currentNode.Right != nil {
   currentNode = currentNode.Right
  } else {
   break
  }
 }
 return currentNode
}

测试代码:

func TestBinarySearchTree1(t *testing.T) {
 // **测试二叉查找树结构如下**
 //            4
 //       3         7
 //    1         6     8
 //
 //      2     5
 tree := NewBinarySearchTree()
 //fmt.Printf("test Insert...n")
 //tree.Print()
 //插入元素
 insertElems := []int{4, 3, 7, 1, 6, 8, 2, 5}
 for _, elem := range insertElems {
  tree.Insert(elem)
 }
 tree.Insert(3)
 tree.Insert(8)
 tree.Insert(8)
     // 查找最小值和最大值
 fmt.Printf("test FindMin and FindMax...n")
 fmt.Printf("find [MIN/MAX] is:[%v/%v]n", tree.FindMin().Value, tree.FindMax().Value)
}

测试效果:

0138440a7d25fd2bb774c9b2d08b37d9.png

中序遍历

要实现二叉排序树的排序，我们可以通过中序遍历即可实现。这一特性，在开始就讲过，下面我们代码来实现验证下吧。

这里实现代码就通过简单的递归来实现了，非递归实现方式，可以参考前文的基础树部分。

且听风吟：我肝了三天，就是为了让你搞懂什么是树​zhuanlan.zhihu.com
6a6dfc32746d66ace8fb74fa9144dc63.png

实现代码:

// 中序遍历实现排序
func (tree *BinarySearchTree) PreOrder() {
 if tree.Root == nil {
  return
 }
 tree.preOrder(tree.Root)
 return
}

// 中序遍历实现排序
func (tree *BinarySearchTree) preOrder(node *BinarySearchNode) {
 if node == nil {
  return
 }
 tree.preOrder(node.Left)
 fmt.Printf("travel value is:%vn", node.Value)
 tree.preOrder(node.Right)
 return
}

测试代码:

func TestBinarySearchTree1(t *testing.T) {
 // **测试二叉查找树结构如下**
 //            4
 //       3         7
 //    1         6     8
 //
 //      2     5
 tree := NewBinarySearchTree()
 //fmt.Printf("test Insert...n")
 //tree.Print()
 //插入元素
 insertElems := []int{4, 3, 7, 1, 6, 8, 2, 5}
 for _, elem := range insertElems {
  tree.Insert(elem)
 }
 tree.Insert(3)
 tree.Insert(8)
 tree.Insert(8)
    fmt.Printf("test PreOrder...n")
 tree.PreOrder()

测试效果:

11f6831137cca7d1487cea1add665637.png

删除

删除操作看起来让人相对头大，情况较复杂，需要分多种情况探讨。不过别担心，我们通过图来一一拆解，最终将会发现也不过是纸老虎而已。

删除有三种情况是要考虑的：

  • 删除的是叶节点，也就是左右子树都为空(特殊情况下,该树也可能只有一个根节点)
  • 删除的节点，可能有左子树或者有右子树（不同时有）
  • 删除的节点，有左子树和右子树

那么针对上面三种情况,我们该怎么对应的去解决呢?

  • 删除的是叶子节点，很明显直接删除即可。
  • 删除的节点只有一个子树，那么该子树直接替换被删除的节点即可。
  • 删除的节点下有两个子树，因为右子树的值都比左子树大，那么用右子树中的最小元素来替换删除的节点，这时二叉查找树的性质又满足了。右子树的最小元素，只要一直往右子树的左边一直找一直找就可以找到。

图解:

情况1:

2c34e191b11d195189f9f1d7c1b3c0d0.png

情况2:

07d1f57dbd2811a7433e9b13f74c774d.png

情况3:

39ab8b29326c19573c217d21fbaa20dc.png

按照上述图解，以及流程说明，我们可以对照着写出实现代码,如下示:

// 查找当前节点和父节点
func (tree *BinarySearchTree) SearchAndParent(value int) (*BinarySearchNode, *BinarySearchNode) {
 if tree.Root == nil {
  return nil, nil
 }
 currentNode := tree.Root
 var parentNode *BinarySearchNode = nil
 for currentNode != nil {
  // 小于子树根节点的值
  if value < currentNode.Value {
   parentNode = currentNode
   currentNode = currentNode.Left
   // 大于子树根节点的值
  } else if value > currentNode.Value {
   parentNode = currentNode
   currentNode = currentNode.Right
   // 找到该值
  } else {
   return currentNode, parentNode
  }
 }
 return currentNode, parentNode
}

// 删除操作
func (tree *BinarySearchTree) Delete(value int) {
 if tree.Root == nil {
  return
 }
 // 判断值是否存在
 currentNode, parentNode := tree.SearchAndParent(value)
 if currentNode == nil {
  return
 }
 // 依照三种情况分类处理
 // 情况1: 该节点即为叶子节点
 if currentNode.Left == nil && currentNode.Right == nil {
  // 特殊情况,只有一个根节点的情况,树置空即可
  if parentNode == nil {
   tree.Root = nil
   return
  }
  // 如果删除的是父节点的左儿子,父节点左孩子置空即直接删除
  if parentNode.Left != nil && currentNode.Value == value {
   parentNode.Left = nil
   return
  } else {
   // 删除的是父节点的右儿子,父节点右孩子置空即直接删除
   parentNode.Right = nil
   return
  }
 }
 //情况2: 存在左子树或者右子树
 // 左子树非空,右子树为空
 if currentNode.Left != nil && currentNode.Right == nil {
  // 删除的是父节点的左儿子,那么直接让当前节点的左儿子变为父节点的左儿子
  if parentNode.Left != nil && currentNode.Value == value {
   parentNode.Left = currentNode.Left
   return
  } else {
   // 删除的是父节点的右儿子,那么直接让当前节点的左儿子变为父节点的右儿子
   parentNode.Right = currentNode.Left
  }
  return
 }
 // 左子树为空,右子树非空
 if currentNode.Left == nil && currentNode.Right != nil {
  // 删除的是父节点的左儿子,那么直接让当前节点的右儿子变为父节点的左儿子
  if parentNode.Left != nil && currentNode.Value == value {
   parentNode.Left = currentNode.Right
   return
  } else {
   // 删除的是父节点的右儿子,那么直接让当前节点的左儿子变为父节点的右儿子
   parentNode.Right = currentNode.Right
  }
  return
 }

 //情况3: 左子树、右子树都非空
 if currentNode.Left != nil && currentNode.Right != nil {
  // 删除的节点下有两个子树，因为右子树的值都比左子树大，那么用右子树中的最小元素来替换删除的节点。
  // 右子树的最小元素，只要一直往右子树的左边一直找一直找就可以找到，替换后二叉查找树的性质又满足了。
  minNode := currentNode.Right
  for minNode.Left != nil {
   minNode = minNode.Left
  }
  //特殊情况: 删除节点的右子树只有一个节点时,此时最小值即为该节点
  if currentNode.Right.Value == minNode.Value {
   currentNode.Value = minNode.Value
   currentNode.Nums = minNode.Nums
   currentNode.Right = nil
   return
  }
  // 删除最小值
  tree.Delete(minNode.Value)
  currentNode.Value = minNode.Value
  currentNode.Nums = minNode.Nums
  return
 }
 return
}
我们增加了 SearchAndParent方法用于查找一个节点的时候，顺便查找到该节点的父节点

完整代码实现

完整代码实现:

https://github.com/yiye93/algo​github.com

^^代码不易，希望大家给个星鼓励下^^

总结

二叉查找树，作为树类型中一种非常重要的数据结构，有着非常广泛的应用，但是二叉查找树具有很高的灵活性，不同的插入顺序，可能造成树的形态差异比较大，如开文介绍的图C，在某些情况下会变成一个长链表，此时的查询效率会大大降低，如何解决这个问题呢，平衡二叉树、红黑树就要派上用场了(二叉查找树也是后面要学习的高级数据结构AVL树，红黑树的基础)，我们会在后续的文章进行介绍。

二叉查找树可能退化为链表，也可能是一棵非常平衡的二叉树，查找，添加，删除元素的时间复杂度取决于树的高度 h。 当二叉树是满的时，树的高度是最小的，此时树节点数量 n 和高度 h 的关系为：h = log(n)。 当二叉树是一个链表时，此时树节点数量 n 和高度 h 的关系为：h = n。 二叉查找树的效率来源其二分查找的特征，时间复杂度在于二叉树的高度，因此查找，添加和删除的时间复杂度范围为 log(n)~n。

下面放一波链接, 本人会持续在上面更新.....

link

  • 公众号: 程序员的进击之路
  • github:
https://github.com/yiye93/algo​github.com
诺北
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉搜索树的插入删除_二叉搜索树_python_
09-29
python数据结构与算法，二叉搜索树的操作，来源中山大学软件学院考试参考代码
博客使用方法
justwaityou1314的博客
06-09 1512
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
LeetCode55--二叉搜索树中的搜索、叶子相似的树
qq_40971025的博客
02-19 116
1.二叉搜索树中的搜索 //给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。 // // 例如， // // //给定二叉搜索树: // // 4 // / \ // 2 7 // / \ // 1 3 // //和值: 2 // // // 你应该返回如下子树: // // // 2 // / \
输出二叉树的叶子结点
与其邻渊羡渔，不如退而结网
04-15 3660
递归出口不能掉，当当前结点t为null时，要return；满足叶子结点的条件输出结点值，否则的话分别递归遍历左子树、右子树； BTree的部分方法： public void displayLeaf() { displayLeaf(root); } private void displayLeaf(BTNode t) { if (t == null) return; if (t.lchild == null &amp.
输出二叉树的叶子结点、高度及重建二叉树
my_miuye的博客
06-01 2532
1.输出二叉树中的叶子结点   思路：在二叉树的遍历算法中增加检测结点的“左右子树是否都为空” void PreorderTraversal( BinTree BT ) { if( BT ) { if( !BT->Left && !BT->Right) //检测左右子树是否都为空 printf("%d ", BT-...
如何打印二叉搜索树的所有叶子?
一个程序媛的成长记录❤
09-05 1753
首先，什么是二叉搜索树？ 之前我把二叉搜索树和线索二叉树混淆了。 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 我觉得打印二叉搜索树的所有叶子...
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
用c语言编写的数据结构相关的二叉树的二叉搜索
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
1.构造一棵二叉排序树并对其进行中序遍历输出；2．在二叉排序树中查找某一关键字，若存在，显示查找成功；若不存在，将其插入到二叉排序树中，再中序遍历输出。
二叉搜索树_二叉搜索树_源码
10-04
一个简单的二叉搜索树的例程，使用不带自平衡的方法实现最简单的二叉搜索树。
编程题型_managed9df_leetcode_二叉搜索树的判断_
10-01
leetcode常见题型汇总与整理，涵盖大部分常见算法题
输出二叉树中的叶子结点
03-08
二叉树部分关于结点的问题有点难，这是个简单易懂的
打印二叉搜索树的叶子结点_线索二叉树
weixin_32821811的博客
01-16 383
产生的背景:存在空间浪费的二叉树如上图的二叉树中，如果没有左孩子或者没有右孩子时，就存在空间浪费，如果二叉树很大时，空间浪费就会非常严重。如果想知道某个结点的前驱和后继时，就要通过遍历一次来确定。所以为了解决这个问题，现在可以利用这些浪费的空间来存储结点的前驱和后继。按照一种的顺序来存储前驱和后继。(例如中序遍历的方式)利用浪费的空间来做有限的线索化目的: 解决空间浪费问题；寻找某个结点的前驱和后...
二叉树和等于某值路径_二叉树问题太复杂？三步走方法解决它！
weixin_39762075的博客
12-06 140
点击关注上方“五分钟学算法”，设为“置顶或星标”，第一时间送达干货。转自面向大象编程，作者nettee本文将以两道题目为例，讨论如何拆解复杂的二叉树问题：LeetCode 1372. Longest ZigZag Path in a Binary Tree[1] 二叉树的最长“之字形”路径(Medium)LeetCode 1373. Maximum Sum BST in Binary T...
二叉树遍历/先序输出叶子结点
qq_43624553的博客
03-03 2886
函数接口定义： void InorderTraversal( BinTree BT ); void PreorderTraversal( BinTree BT ); void PostorderTraversal( BinTree BT ); void LevelorderTraversal( BinTree BT ); BinTree结构定义如下： typedef struct TNode *Position; typedef Position BinTree; struct TNode{ El
数据结构_树和二叉树(1)
LIUUGNAY的博客
10-13 460
树和二叉树树的基本概念树的定义基本术语 树的基本概念 树的定义 树是N(N>=0)个结点的有限集合，N=0时，称为空树。 对于任意一个非空树，都有： 有且仅有一个特定的称为根的结点。 当N>1时，其余结点可分为m(m>0)个互不相交的有限集合T1, T2, …, Tm，其中每一个集合本身又是一棵树，并且称为根结点的子树。 树作为一种逻辑结构，同时也是一种分层结构，具有以下两个特点： 树的根节点没有前驱结点，除了根节点之外的所有结点有且仅有一个前驱节点。 树中所有结点可以有零个或多个后
二叉树-代码
qq_45300403的博客
12-30 168
#include <iostream > using namespace std; struct BiNode { int data; BiNode* rchild; BiNode* lchild; }; class BiTree { public: BiTree() { root = Creat(); } ~BiTree() { Release(root); } void...
浅谈数据库文件存储原理
轩1024的博客
09-18 2478
数据库文件存储原理 在说数据库存储原理之前，我们不妨先思考个问题。假如我们是数据库存储引擎的设计者，我们会如何在磁盘上存储数据。当然存储引擎是个很复杂的东西，但我们可以简单的思考数据的存储方式，用什么样的数据结构比价合适，合理，性能最好。 我们学过很多数据结构：集合，数组，链表，hash表，树，堆，栈等等等等。它们是我们存储数据的手段。之前学习Python的时候，有本书叫做《Python学习手册》刚开始它就让我们学习实现写一个数据库。刚开始用元祖，列表这些简单的数据结构，后面用到复杂的字典类型。我们发现
打印二叉搜索树的叶子结点_数据结构 | 四种平衡二叉树介绍
weixin_36002897的博客
01-11 448
欢迎观看论文系列二叉树(Binary Tree)指的是树中结点的度不大于2的有序树，其递归定义是：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树同样也是二叉树。二叉树是树形结构的一个重要类型，许多实际问题抽象出来的数据结构往往都是二叉树的类型。即使是一般的树也可以转化为二叉树，并且二叉树的存储结构和算法相对而言都比较简单。...
如何用递归处理一个数组中的数据成为一个树结构_数据结构浅析(11)-树性结构：二叉查找树和笛卡尔树...
weixin_39528467的博客
12-06 148
本系列文章(1) 数据结构浅析(1)-什么是数据结构？(2) 数据结构浅析(2)-集合(3) 数据结构浅析(3)-线性结构：数组(4) 数据结构浅析(4)-线性结构：线性表(5) 数据结构浅析(5)-线性结构：串(6) 数据结构浅析(6)-线性结构：栈(7) 数据结构浅析(7)-线性结构：队列和双端队列(8) 数据结构浅析(8)-树性结构：树和无序树(9) 数据结构浅析(9)-树性结构：有序树和二...
平衡二叉排序树：＿＿＿。
最新发布
05-10
平衡二叉排序树是一种特殊的二叉排序树，它通过旋转操作保持树的左右子树高度差不超过1，从而达到更加高效的查找、插入、删除等操作。平衡二叉排序树的常见实现包括红黑树、AVL树、Treap等。其中，红黑树是一种比较...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值