树结构-二分搜索树

最新推荐文章于 2023-05-24 21:24:43 发布
最新推荐文章于 2023-05-24 21:24:43 发布
阅读量245 收藏
点赞数 1
分类专栏： 数据结构 Golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiwutudou/article/details/81626639
版权

1.树的定义

         树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的树,其中我们平常使用的目录就是常见的树;

          

1.1 二叉树的定义

        在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。

                        

1.2 二分搜索树

            二分搜索树就是左子树的键值小于根节点，右子树键值大于根节点的树。而且左右子树是递归定义。简单来说就是任意节点左子树的树。这里主要讨论的是二分搜索树也就是二叉树。其应用在于查找表，以及字典结构的时候。其查找速度非常之快，而且可以用其求各种算法例如max ,min ,rank 等等

                       

2. 二分搜索树的代码实现

    2.1.1 instet

package arr

//二分搜索树的构建
type Two_tree struct {
	E     int
	Left  *Two_tree
	Right *Two_tree
}

var size = 0
/**
 * add二分搜索树添加
 *
 */
func (tree *Two_tree) Add(E int) {
	if tree.E == 0 && tree.Left == nil && tree.Right == nil {
		tree.E = E
		size++
	} else {
		inster(tree, E)
	}
}

//inster递归添加
func inster(tree *Two_tree, E int) {
	//递归基本问题
	if tree.E == E {
		//重复存在
		return
	} else if E < tree.E && tree.Left == nil {
		//插入左子树
		tree.Left = &Two_tree{E, nil, nil}
		return
		size++
	} else if E > tree.E && tree.Right == nil {
		//插入右子树
		tree.Right = &Two_tree{E, nil, nil}
		return
		size++
	}
	//递归转化更小问题
	if E < tree.E {
		inster(tree.Left, E)
	} else {
		inster(tree.Right, E)
	}

}

 

2.1.2 inster优化(1)

package arr

//二分搜索树的构建
type Two_tree struct {
	E     int
	Left  *Two_tree
	Right *Two_tree
}

type Root_tree struct {
	Root *Two_tree
}

var size = 0

/**
 * add二分搜索树添加
 *
 */
func (root *Root_tree) Add(E int) {
	root.Root=inster(root.Root, E)
}

//inster递归添加
func inster(tree *Two_tree, E int) *Two_tree {
	//判断是否是根
	if tree == nil {
		size++
		tree = &Two_tree{E, nil, nil}
		return tree
	}

	//递归转化更小问题
	if E < tree.E {
		tree.Left = inster(tree.Left, E)
	} else if E > tree.E {
		tree.Right = inster(tree.Right, E)
	}
	return tree
}

main.go

package main

import (
	"./arr"
	"fmt"
)

func main() {
	var tree arr.Root_tree

	tree.Add(1)
	fmt.Println(tree.Root.E)

	tree.Add(11)
	fmt.Println(tree.Root.Right.E)

	tree.Add(9)
	fmt.Println(tree.Root.Right.Left.E)

}

   

2.1.3inster优化(2)

package arr

//二分搜索树的构建
type Two_tree struct {
	E     int
	Left  *Two_tree
	Right *Two_tree
}

var (
	size           = 0
	tree *Two_tree = nil
)

/**
 * add二分搜索树添加
 *
 */
func (tree *Two_tree) Add(E int) {
	tree = inster(tree, E)
}

//inster递归添加
func inster(tree *Two_tree, E int) *Two_tree {
	//判断是否是根
	if tree == nil {
		size++
		tree = &Two_tree{E, nil, nil}
		return tree
	}

	//递归转化更小问题
	if E < tree.E {
		tree.Left = inster(tree.Left, E)
	} else if E > tree.E {
		tree.Right = inster(tree.Right, E)
	}
	return tree
}

   main.go

package main

import (
	"./arr"
	"fmt"
)

func main() {
	var tree arr.Two_tree
	fmt.Println(tree)

	tree.Add(1)
	fmt.Println(tree)
	fmt.Println(tree.Right.E)

	tree.Add(11)
	fmt.Println(tree.Right.Right.E)

	tree.Add(9)
	fmt.Println(tree.Right.Right.Left.E)

}

     

2.2 empty

/**
 * Empty二分搜索树的查询判断
 * @E int 要查询的数字
 */
func (root *Root_tree) Empty(E int) bool {
	return empty(root.Root, E)
}

//empty
func empty(tree *Two_tree, E int) bool {
	if tree == nil {
		return false
	}
	if E == tree.E {
		return true
	} else if E < tree.E {
		return empty(tree.Left, E)
	} else if E > tree.E {
		return empty(tree.Right, E)
	}
	return false
}

     

2.3二分搜索树的前序遍历

     2.3.1 前序遍历

            

/**
 * Preorder二分搜索树前置遍历
 */
func (root *Root_tree) Preorder() {
	preorder(root.Root)
}

//preorder递归前置遍历
func preorder(tree *Two_tree) {
	if tree == nil {
		return
	}
	fmt.Println(tree.E)
	preorder(tree.Left)
	preorder(tree.Right)
}

 

2.3.2 中序遍历(顺序遍历)

              

/**
 * Inorder二分搜索树的中序遍历
 */
func (root *Root_tree) Inorder() {
	inorder(root.Root)
}

//inorder递归中序遍历
func inorder(tree *Two_tree) {
	if tree == nil {
		return
	}
	preorder(tree.Left)
	fmt.Println(tree.E)
	preorder(tree.Right)
}

 

2.3.3 后序遍历

           

/**
 * Postorder二分搜索树的后序遍历
 */
func (root *Root_tree) Postorder()  {
	postorder(root.Root)
}

//postorder递归后续遍历
func postorder(tree *Two_tree)  {
	if tree == nil {
		return
	}
	preorder(tree.Left)
	preorder(tree.Right)
	fmt.Println(tree.E)
}

           

2.3.4 非递归前序遍历(深度优先遍历)

     模拟系统栈的压入和取出;

               

/**
 * PreorderNR二分搜索树的非递归前序遍历
 */
func (root *Root_tree) PreorderNR() {
	preordernr(root.Root)
}

//preordernr非递归遍历
func preordernr(tree *Two_tree) {
	l := list.New()
	//入栈第一个元素
	l.PushFront(tree)
	for l.Len() != 0 {
		//截取第一个元素并转化成结构体
		ll := l.Remove(l.Front()).(*Two_tree)
		fmt.Println(ll.E)
		if ll.Left != nil {
			l.PushFront(ll.Left)
		}
		if ll.Right != nil {
			l.PushFront(ll.Right)
		}
	}

}

 

2.3.5 层序遍历(广度优先遍历)

            

/**
 * levelorder二分搜索树的广度优先遍历
 */
func (root *Root_tree) Levelorder() {
	levelorder(root.Root)
}

//levelorder广度优先
func levelorder(tree *Two_tree)  {
	l := list.New()
	//入栈第一个元素
	l.PushBack(tree)
	for l.Len() != 0 {
		//截取第一个元素并转化成结构体
		ll := l.Remove(l.Front()).(*Two_tree)
		fmt.Println(ll.E)
		if ll.Left != nil {
			l.PushBack(ll.Left)
		}
		if ll.Right != nil {
			l.PushBack(ll.Right)
		}
	}
}

 

2.3.6 删除最小树(最大树)

/**
 * Removemin删除二分搜索树的最小值,并返回根
 */
func (root *Root_tree) Removemin() *Two_tree {
	return removemin(root.Root)
}

//removemin递归删除最小值
func removemin(tree *Two_tree) *Two_tree {
	if tree.Left == nil {
		right := tree.Right
		tree.Right = nil
		return right
	}
	//使原右子树代替左子树
	tree.Left=removemin(tree.Left)
	return tree
}

 

2.3.7 删除任意节点

                      

**        10
 *       /    \
		7     15
 *     / \    /
      2   8  11
 *     \   \  \
        3   9  12
 */
//remove 递归删除任意值
func remove(tree *Two_tree, e int) *Two_tree {
	if tree == nil {
		return nil
	}
	//寻找e的位置
	if e < tree.E {
		tree.Left = remove(tree.Left, e)
		return tree
	} else if e > tree.E {
		tree.Right = remove(tree.Right, e)
		return tree
	} else {
		//删除左子树为空
		if tree.Left == nil {
			right := tree.Right
			tree.Right = nil
			return right
		}
		//删除右子树为空
		if tree.Right == nil {
			left := tree.Left
			tree.Left = nil
			return left
		}
		//删除元素左右子树均不为空
		//找到待删除节点的最小节点,即待删除节点的右子树的最小节点
		//用这个节点代替删除节点,待删除左子树继续拼接
		successor := minimum(tree.Right)        //待删除节点的最小节点
		successor.Right = removemin(tree.Right) //删除操作
		successor.Left = tree.Left
		tree.Left = nil
		tree.Right = nil
		return successor
	}
}

 

2.3.8 全部代码奉上

bst.go

package arr

import (
	"fmt"
	"container/list"
)

//二分搜索树的构建
type Two_tree struct {
	E     int
	Left  *Two_tree
	Right *Two_tree
}

type Root_tree struct {
	Root *Two_tree
}

var size = 0

/**
 * add 二分搜索树添加
 * @E int 插入的数字
 */
func (root *Root_tree) Add(E int) {
	root.Root = add(root.Root, E)
}

/**
 * Empty 二分搜索树的查询判断
 * @E int 要查询的数字
 */
func (root *Root_tree) Empty(E int) bool {
	return empty(root.Root, E)
}

/**
 * Preorder 二分搜索树前序遍历
 */
func (root *Root_tree) Preorder() {
	preorder(root.Root)
}

/**
 * Inorder 二分搜索树的中序遍历
 */
func (root *Root_tree) Inorder() {
	inorder(root.Root)
}

/**
 * Postorder二分搜索树的后序遍历
 */
func (root *Root_tree) Postorder() {
	postorder(root.Root)
}

/**
 * PreorderNR 二分搜索树的非递归前序遍历
 */
func (root *Root_tree) PreorderNR() {
	preordernr(root.Root)
}

//preordernr 非递归遍历
func preordernr(tree *Two_tree) {
	l := list.New()
	//入栈第一个元素
	l.PushBack(tree)
	for l.Len() != 0 {
		//截取第一个元素并转化成结构体
		ll := l.Remove(l.Back()).(*Two_tree)
		fmt.Println(ll.E)
		if ll.Right != nil {
			l.PushBack(ll.Right)
		}
		if ll.Left != nil {
			l.PushBack(ll.Left)
		}
	}
}

/**
 * levelorder 二分搜索树的广度优先遍历
 */
func (root *Root_tree) Levelorder() {
	levelorder(root.Root)
}

//levelorder 广度优先
func levelorder(tree *Two_tree) {
	l := list.New()
	//入栈第一个元素
	l.PushBack(tree)
	for l.Len() != 0 {
		//截取第一个元素并转化成结构体
		ll := l.Remove(l.Front()).(*Two_tree)
		fmt.Println(ll.E)
		if ll.Left != nil {
			l.PushBack(ll.Left)
		}
		if ll.Right != nil {
			l.PushBack(ll.Right)
		}
	}
}

/**
 * minimum 查询二分搜索树的最小元素
 */
func (root *Root_tree) Minimum() *Two_tree {
	return minimum(root.Root)
}

/**
 * Removemin 删除二分搜索树的最小值,并返回根
 */
func (root *Root_tree) Removemin() *Two_tree {
	return removemin(root.Root)
}

/**
 * Remove 删除二分搜索树的任意值
 * @e int 指定的e
 */
func (root *Root_tree) Remove(e int) *Two_tree {
	return remove(root.Root, e)
}

/**        10
 *       /    \
		7     15
 *     / \    /
      2   8  11
 *     \   \  \
        3   9  12
 */
//remove 递归删除任意值
func remove(tree *Two_tree, e int) *Two_tree {
	if tree == nil {
		return nil
	}
	//寻找e的位置
	if e < tree.E {
		tree.Left = remove(tree.Left, e)
		return tree
	} else if e > tree.E {
		tree.Right = remove(tree.Right, e)
		return tree
	} else {
		//删除左子树为空
		if tree.Left == nil {
			right := tree.Right
			tree.Right = nil
			return right
		}
		//删除右子树为空
		if tree.Right == nil {
			left := tree.Left
			tree.Left = nil
			return left
		}
		//删除元素左右子树均不为空
		//找到待删除节点的最小节点,即待删除节点的右子树的最小节点
		//用这个节点代替删除节点,待删除左子树继续拼接
		successor := minimum(tree.Right)        //待删除节点的最小节点
		successor.Right = removemin(tree.Right) //删除操作
		successor.Left = tree.Left
		tree.Left = nil
		tree.Right = nil
		return successor
	}
}

/**        10
 *       /    \
		7     15
 *     / \    /
      2   8  11
 *     \   \  \
        3   9  12
 */
//removemin 递归删除最小值
func removemin(tree *Two_tree) *Two_tree {
	if tree.Left == nil {
		right := tree.Right
		tree.Right = nil
		return right
	}
	//使原右子树代替左子树
	tree.Left = removemin(tree.Left)
	return tree
}

//minimum 递归查询二分搜索树的最小元素
func minimum(tree *Two_tree) *Two_tree {
	if tree.Left == nil {
		return tree
	}
	return minimum(tree.Left)
}

//postorder 递归后续遍历
func postorder(tree *Two_tree) {
	if tree == nil {
		return
	}
	preorder(tree.Left)
	preorder(tree.Right)
	fmt.Println(tree.E)
}

//inorder 递归中序遍历
func inorder(tree *Two_tree) {
	if tree == nil {
		return
	}
	preorder(tree.Left)
	fmt.Println(tree.E)
	preorder(tree.Right)
}

//preorder 递归前序遍历
func preorder(tree *Two_tree) {
	if tree == nil {
		return
	}
	fmt.Println(tree.E)
	preorder(tree.Right)
	preorder(tree.Left)
}

//empty 递归判断
func empty(tree *Two_tree, E int) bool {
	if tree == nil {
		return false
	}
	if E == tree.E {
		return true
	} else if E < tree.E {
		return empty(tree.Left, E)
	} else if E > tree.E {
		return empty(tree.Right, E)
	}
	return false
}

//add 递归添加
func add(tree *Two_tree, E int) *Two_tree {
	//判断是否是根
	if tree == nil {
		size++
		tree = &Two_tree{E, nil, nil}
		return tree
	}

	//递归转化更小问题
	if E < tree.E {
		tree.Left = add(tree.Left, E)
	} else if E > tree.E {
		tree.Right = add(tree.Right, E)
	}
	return tree
}

 

 

 

 

 

   

 

 

yí無所冇
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分搜索树（Binary Search Tree）
qq_48019875的博客
11-22 2357
目录树结构一、为什么要有树结构二、二分搜索树的基础 树结构 一、为什么要有树结构 树结构本身是一种天然的组织结构 高效 二、二分搜索树的基础
数据结构 树结构-二分搜索树
12-22
二、为什么要有树结构 2.1 树结构是一种天然的组织结构 比如说电脑中的文件夹，我们需要找到一个特定的文件，需要到某个文件夹下去找这个文件，计算机的文件存储的结构来源于生活。 再比如说图书馆，我们知道图书馆...
二分查找和二分查找树
forget_fish的博客
02-27 4482
预备知识：二分查找算法（折半查找法） 首先假设表中的元素时升序排列的，将表中间的位置和查找关键字比较： 1、如果相等，则查找成功 2、否则利用中间位置前后的两个子表： 1）如果中间位置大于目标更好换剪子，则用同样的方式再前一子表进行查找 2）否则在后一子表进行查找 重复上述过程，满足条件则成功；否则没有子表则失败。 一、插入位置 LeetCode35 题目： 给定一个排序数组和一个目标值，在数组...
数据结构基础--搜索树
RXY24601的博客
11-13 1314
包括：二叉搜索树，平衡二叉树，m叉搜索树，B-树
数据结构（五）——二分搜索树
baoyu_G的博客
07-14 328
    简单的说，二分搜索树是一种某个节点的左孩子小于这个节点的值，右孩子大于这个节点的值的特殊二叉树。（什么是二叉树就不说了），特点是：二分搜索树的中序遍历得到的结果是有序的；下面主要讲二分搜索树的创建，递归的先序、中序和后序遍历，借助栈的先序非递归遍历，层序遍历(广度优先遍历)：    首先是二分搜索树的创建，向二分搜索树中添加节点的实现:思路：如果树为空的话，创建一个Node存储要添加的数据...
数据结构与算法之二分搜索树
Admin_Lian的博客
03-06 278
目录(一) 定义(二) 自定义二分搜索树BinarySearchTree1. 新建自定义二分搜索树类BinarySearchTree2. 自定义二分搜索树的增加操作3. 自定义二分搜索树的查询操作4. 自定义二分搜索树的遍历操作5. 自定义二分搜索树的删除操作 (一) 定义 树(Tree): 是一种动态的数据结构. 它是由 n(n>=1) 个有限结点组成一个具有层次关系的集合. 也可...
数据结构之利用PHP实现二分搜索树
12-16
这篇文章是介绍 二叉树 和 二分搜索树，然后通过 PHP 代码定义一下 二分搜索树 的节点，使用递归思想操作向二分搜索树添加元素，然后实现了递归判断二分搜索树上是否包含某个元素，最后分别实现了前序遍历、中序遍历...
数据结构C++二分搜索树
05-11
实现二分搜索树的查找、删除、输出 包含构造很析构函数
8. 二分搜索树-AVL的前身1
08-03
原因在于数组插入元素的低效性，除了定位元素的成本以外，为了保持数组元素的有序性，必须挪动响应的元素，当数组较大时，每一次的插入操作都将带来不菲的额外代价二分搜索
Java基于二分搜索树、链表的实现的集合Set复杂度分析实例详解
08-19
主要介绍了Java基于二分搜索树、链表的实现的集合Set复杂度分析,结合实例形式详细分析了Java基于二分搜索树、链表的实现的集合Set复杂度分析相关操作技巧与注意事项,需要的朋友可以参考下
可折叠树形菜单代码（带搜索功能）
01-09
jQuery折叠树形菜单代码基于jquery.1.10.2.min.js制作，带搜索功能，搜索关键字，直接显示菜单项，展开收缩树形菜单。
数据结构与算法：树形查找
墨城烟柳ベ旧人殇的博客
05-24 1832
新星计划：数据结构与算法，学习笔记，创作打卡3！本文主要是对树形查找中的二叉排序树、平衡二叉树、红黑树、B树和B+树的详细介绍！
数据结构：搜索树
m0_55644719的博客
05-21 1895
文章目录一.搜索树1.1什么是搜索树1.2搜索树特点1.3二分搜索树核心操作 一.搜索树 1.1什么是搜索树 基础二叉树主要是做题，基础二叉树的衍生结构在实际工程中有着广泛的应用 堆=>完全二叉树 AVL,RBTree,B树=》搜索树 BST：二分搜索树，二叉搜索树，二叉排序树 1.2搜索树特点 1.也是个二叉树 2.每个树的左子树的所有节点值<树根节点<所有右子树的节点值（当前树中的所有子树仍然遵循这个规则） KDK中的BST，不存在重复节点 3.存储的节点必须具备可以比较的能力（要么实
盘点常用的搜索树
S_X007的博客
11-15 261
转载：https://www.cnblogs.com/cpcpp/p/13529829.html 盘点常用的搜索树 树的典型应用有很多，比如计算机的文件系统就是一棵树，根目录就是根节点。树的重要应用之一就是搜索树，搜索树通常分为二叉搜索树和多路搜索树。 二叉搜索树 二叉搜索树是一颗有序的树，每个结点不小于其左子树任意结点的值，不大于右子树任意结点的值。二叉搜索树还有一个有趣的特性，它的中序遍历得到的是有序数列。 二叉搜索树能提高搜索的效率，搜索次数最多是树的深度次，最少能到log(n)。 搜索树有搜索，插入
树形结构的3种搜索方式示例分享
sdau20163940的博客
08-05 3736
树形结构在各项大赛中成为必备的知识之一，尤其是建立在树形结构基础上的搜索算法！ 代码： /** 树的3种常见搜索方式 1.二叉树方式（每一层只有0和1） 2.满m叉树（每一层都有0 到m - 1） 3.子集树，也称为全排列树 */ #include #include #include #include #include using namespace std; const i
关于树表结构的查找算法
IT_BOY的博客
04-03 567
关于树表结构的查找算法 设计的知识点为： 二叉查找树 平衡二叉树 B树 B+树 红黑树 1、二叉查找树： 二叉查找树就是左结点小于根节点，右结点大于根节点的一种排序树，也叫二叉搜索树。也叫BST，英文Binary Sort Tre...
树形结构的查找
小菜比的博客
10-14 2487
树形结构的查找 二叉排序树（Binary Sort Tree）BST 定义：二叉排序树要么是一棵空树 要么是一棵具有如下特性的二叉树：①左子树非空，左子树的关键字都小于根节点的关键字。 ②右子树非空，右子树的关键字都大于根节点的关键字。 ③左右子树本身也是一棵二叉排序树。 对排序二叉树的中序遍历可以得到一个递增的有序序列。 Bsnode*bst_search(bitree T, elemtype ...
JS对树结构进行模糊搜索，支持多关键字多字段搜索以及排序
BWater_monster的博客
11-30 2467
JS对树结构进行模糊搜索，支持多关键字多字段搜索以及排序
matlab编程实现二进制树搜索与二分支搜索rfid
最新发布
12-07
通过编程实现二分搜索算法，可以在数组中快速查找RFID标签，并返回其位置。 综上所述，可以在Matlab中通过编程实现二进制树搜索和二分支搜索RFID。通过这两种算法，可以实现高效的RFID标签搜索和索引功能，提高RFID...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值