二叉排序树、平衡二叉树以及多路查找树

最新推荐文章于 2021-07-03 20:38:00 发布
最新推荐文章于 2021-07-03 20:38:00 发布
阅读量144 收藏
点赞数
分类专栏： Java数据结构与算法系列 文章标签： 数据结构 java 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/prefect_start/article/details/116381124
版权
1、二叉排序树

二叉排序树：BST: (Binary Sort(Search) Tree), 对于二叉排序树的 任何一个非叶子节点，要求 左子节点的值比当前节点的值小， 右子节点的值比当前节点的值大。
特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点

比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树为：
在这里插入图片描述

1.1、一个数组创建、中序遍历二叉排序树
//创建Node结点
class Node {
	int value;
	Node left;
	Node right;
	public Node(int value) {
		this.value = value;
	}
	@Override
	public String toString() {
		return "Node [value=" + value + "]";
	}
	//添加结点的方法
	//递归的形式添加结点，注意需要满足二叉排序树的要求
	public void add(Node node) {
		if(node == null) {
			return;
		}
		//判断传入的结点的值，和当前子树的根结点的值关系
		if(node.value < this.value) {
			//如果当前结点左子结点为null
			if(this.left == null) {
				this.left = node;
			} else {
				//递归的向左子树添加
				this.left.add(node);
			}
		} else { //添加的结点的值大于 当前结点的值
			if(this.right == null) {
				this.right = node;
			} else {
				//递归的向右子树添加
				this.right.add(node);
			}
		}
	}

	//中序遍历
	public void infixOrder() {
		if(this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null) {
			this.right.infixOrder();
		}
	}
}

//创建二叉排序树
class BinarySortTree {
	private Node root;
	public Node getRoot() {
		return root;
	}
	//添加结点的方法
	public void add(Node node) {
		if(root == null) {
			root = node;//如果root为空则直接让root指向node
		} else {
			root.add(node);
		}
	}
	//中序遍历
	public void infixOrder() {
		if(root != null) {
			root.infixOrder();
		} else {
			System.out.println("二叉排序树为空，不能遍历");
		}
	}
}

public class BinarySortTreeDemo {

	public static void main(String[] args) {
		int[] arr = {7, 3, 10, 12, 5, 1, 9, 2};
		BinarySortTree binarySortTree = new BinarySortTree();
		//循环的添加结点到二叉排序树
		for(int i = 0; i< arr.length; i++) {
			binarySortTree.add(new Node(arr[i]));
		}

		//中序遍历二叉排序树
		System.out.println("中序遍历二叉排序树~");
		binarySortTree.infixOrder(); // 1, 3, 5, 7, 9, 10, 12
	}
}
1.2、删除二叉排序树的节点

二叉排序树的删除情况比较复杂，有下面三种情况需要考虑

  • 点 删除叶子节点 (比如：2, 5, 9, 12)
  • 删除点 只有一颗子树的节点 (比如：1)
  • 删除 有两颗子树的节点. (比如：7, 3，10 )
1.2.1、第一种情况:

删除叶子节点 (比如：2, 5, 9, 12)思路

  1. 需求先去找到要删除的结点 targetNode
  2. 找到 targetNode 的 父结点 parent
  3. 确定 targetNode 是 parent 的左子结点 还是右子结点
  4. 根据前面的情况来对应删除
    左子结点 parent.left = null
    右子结点 parent.right = null;
1.2.2、第二种情况: 删除只有一颗子树的节点 比如 1

思路

  1. 需求先去找到要删除的结点 targetNode
  2. 找到 targetNode 的 父结点 parent
  3. 确定 targetNode 的子结点是左子结点还是右子结点
  4. targetNode 是 parent 的左子结点还是右子结点
  5. 如果 targetNode 有左子结点
    5.1 如果 targetNode 是 parent 的左子结点
    parent.left = targetNode.left;
    5.2 如果 targetNode 是 parent 的右子结点
    parent.right = targetNode.left;
  6. 如果 targetNode 有右子结点
    6.1 如果 targetNode 是 parent 的左子结点
    parent.left = targetNode.right;
    6.2 如果 targetNode 是 parent 的右子结点
    parent.right = targetNode.right
3.3、情况三 ： 删除有两颗子树的节点. (比如：7, 3，10 )

思路

  1. 需求先去找到要删除的结点 targetNode
  2. 找到 targetNode 的 父结点 parent
  3. 从 targetNode 的右子树找到最小的结点
  4. 用一个临时变量，将 最小结点的值保存 temp = 11
  5. 删除该最小结点
  6. targetNode.value = temp
//创建Node结点
class Node {
	int value;
	Node left;
	Node right;
	public Node(int value) {

		this.value = value;
	}


	//查找要删除的结点
	/**
	 *
	 * @param value 希望删除的结点的值
	 * @return 如果找到返回该结点，否则返回null
	 */
	public Node search(int value) {
		if(value == this.value) { //找到就是该结点
			return this;
		} else if(value < this.value) {//如果查找的值小于当前结点，向左子树递归查找
			//如果左子结点为空
			if(this.left  == null) {
				return null;
			}
			return this.left.search(value);
		} else { //如果查找的值不小于当前结点，向右子树递归查找
			if(this.right == null) {
				return null;
			}
			return this.right.search(value);
		}

	}
	//查找要删除结点的父结点
	/**
	 *
	 * @param value 要找到的结点的值
	 * @return 返回的是要删除的结点的父结点，如果没有就返回null
	 */
	public Node searchParent(int value) {
		//如果当前结点就是要删除的结点的父结点，就返回
		if((this.left != null && this.left.value == value) ||
				(this.right != null && this.right.value == value)) {
			return this;
		} else {
			//如果查找的值小于当前结点的值, 并且当前结点的左子结点不为空
			if(value < this.value && this.left != null) {
				return this.left.searchParent(value); //向左子树递归查找
			} else if (value >= this.value && this.right != null) {
				return this.right.searchParent(value); //向右子树递归查找
			} else {
				return null; // 没有找到父结点
			}
		}

	}

	@Override
	public String toString() {
		return "Node [value=" + value + "]";
	}


	//添加结点的方法
	//递归的形式添加结点，注意需要满足二叉排序树的要求
	public void add(Node node) {
		if(node == null) {
			return;
		}
		//判断传入的结点的值，和当前子树的根结点的值关系
		if(node.value < this.value) {
			//如果当前结点左子结点为null
			if(this.left == null) {
				this.left = node;
			} else {
				//递归的向左子树添加
				this.left.add(node);
			}
		} else { //添加的结点的值大于 当前结点的值
			if(this.right == null) {
				this.right = node;
			} else {
				//递归的向右子树添加
				this.right.add(node);
			}

		}
	}

	//中序遍历
	public void infixOrder() {
		if(this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null) {
			this.right.infixOrder();
		}
	}
}

//创建二叉排序树
class BinarySortTree {
	private Node root;
	public Node getRoot() {
		return root;
	}

	//查找要删除的结点
	public Node search(int value) {
		if(root == null) {
			return null;
		} else {
			return root.search(value);
		}
	}

	//查找父结点
	public Node searchParent(int value) {
		if(root == null) {
			return null;
		} else {
			return root.searchParent(value);
		}
	}

	//编写方法:
	//1. 返回的 以node 为根结点的二叉排序树的最小结点的值
	//2. 删除node 为根结点的二叉排序树的最小结点
	/**
	 *
	 * @param node 传入的结点(当做二叉排序树的根结点)
	 * @return 返回的 以node 为根结点的二叉排序树的最小结点的值
	 */
	public int delRightTreeMin(Node node) {
		Node target = node;
		//循环的查找左子节点，就会找到最小值
		while(target.left != null) {
			target = target.left;
		}
		//这时 target就指向了最小结点
		//删除最小结点
		delNode(target.value);
		return target.value;
	}


	//删除结点
	public void delNode(int value) {
		if(root == null) {
			return;
		}else {
			//1.需求先去找到要删除的结点  targetNode
			Node targetNode = search(value);
			//如果没有找到要删除的结点
			if(targetNode == null) {
				return;
			}
			//如果我们发现当前这颗二叉排序树只有一个结点
			if(root.left == null && root.right == null) {
				root = null;
				return;
			}

			//去找到targetNode的父结点
			Node parent = searchParent(value);
			//如果要删除的结点是叶子结点
			if(targetNode.left == null && targetNode.right == null) {
				//判断targetNode 是父结点的左子结点，还是右子结点
				if(parent.left != null && parent.left.value == value) { //是左子结点
					parent.left = null;
				} else if (parent.right != null && parent.right.value == value) {//是由子结点
					parent.right = null;
				}
			} else if (targetNode.left != null && targetNode.right != null) { //删除有两颗子树的节点
				int minVal = delRightTreeMin(targetNode.right);
				targetNode.value = minVal;


			} else { // 删除只有一颗子树的结点
				//如果要删除的结点有左子结点
				if(targetNode.left != null) {
					if(parent != null) {
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value) {
							parent.left = targetNode.left;
						} else { //  targetNode 是 parent 的右子结点
							parent.right = targetNode.left;
						}
					} else {
						root = targetNode.left;
					}
				} else { //如果要删除的结点有右子结点
					if(parent != null) {
						//如果 targetNode 是 parent 的左子结点
						if(parent.left.value == value) {
							parent.left = targetNode.right;
						} else { //如果 targetNode 是 parent 的右子结点
							parent.right = targetNode.right;
						}
					} else {
						root = targetNode.right;
					}
				}

			}

		}
	}

	//添加结点的方法
	public void add(Node node) {
		if(root == null) {
			root = node;//如果root为空则直接让root指向node
		} else {
			root.add(node);
		}
	}
	//中序遍历
	public void infixOrder() {
		if(root != null) {
			root.infixOrder();
		} else {
			System.out.println("二叉排序树为空，不能遍历");
		}
	}
}

package com.atguigu.binarysorttree;

public class BinarySortTreeDemo {

	public static void main(String[] args) {
		int[] arr = {7, 3, 10, 12, 5, 1, 9, 2};
		BinarySortTree binarySortTree = new BinarySortTree();
		//循环的添加结点到二叉排序树
		for(int i = 0; i< arr.length; i++) {
			binarySortTree.add(new Node(arr[i]));
		}

		//中序遍历二叉排序树
		System.out.println("中序遍历二叉排序树~");
		binarySortTree.infixOrder(); // 1, 3, 5, 7, 9, 10, 12

		//测试一下删除叶子结点


	    binarySortTree.delNode(12);


	    binarySortTree.delNode(5);
	    binarySortTree.delNode(10);
	    binarySortTree.delNode(2);
	    binarySortTree.delNode(3);
	    binarySortTree.delNode(9);
	    binarySortTree.delNode(1);
	    binarySortTree.delNode(7);
	    
		System.out.println("root=" + binarySortTree.getRoot());
		System.out.println("删除结点后");
		binarySortTree.infixOrder();
	}

}

BST 存在的问题分析:
给一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST)：

在这里插入图片描述

  1. 左子树全部为空，从形式上看，更像一个单链表.
  2. 插入速度没有影响
  3. 查询速度明显降低(因为需要依次比较), 不能发挥 BST的优势，因为每次还需要比较左子树，其查询速度比
    单链表还慢
  4. 解决方案-平衡二叉树(AVL)
2、平衡二叉树

平衡二叉树也叫平衡 二叉搜索树（Self-balancing binary search tree）又被称为 AVL 树， 可以保证查询效率较高。
具有以下特点：它是 一 棵空树或 它的左右两个子树的高度差的绝对值不超过 1，并且 左右两个子树都是一棵平衡二叉树。
平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。

2.1、单旋转（左旋转）

在这里插入图片描述

// 返回左子树的高度
	public int leftHeight() {
		if (left == null) {
			return 0;
		}
		return left.height();
	}

	// 返回右子树的高度
	public int rightHeight() {
		if (right == null) {
			return 0;
		}
		return right.height();
	}

	// 返回 以该结点为根结点的树的高度
	public int height() {
		return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
	}
	
	//左旋转方法
	private void leftRotate() {
		
		//创建新的结点，以当前根结点的值
		Node newNode = new Node(value);
		//把新的结点的左子树设置成当前结点的左子树
		newNode.left = left;
		//把新的结点的右子树设置成带你过去结点的右子树的左子树
		newNode.right = right.left;
		//把当前结点的值替换成右子结点的值
		value = right.value;
		//把当前结点的右子树设置成当前结点右子树的右子树
		right = right.right;
		//把当前结点的左子树(左子结点)设置成新的结点
		left = newNode;
		
		
	}
2.2、单旋转（右旋转）

在这里插入图片描述

//右旋转
	private void rightRotate() {
		Node newNode = new Node(value);
		newNode.right = right;
		newNode.left = left.right;
		value = left.value;
		left = left.left;
		right = newNode;
	}
2.3、双旋转在这里插入图片描述

思路：

  1. 当符号右旋转的条件时
  2. 如果它的左子树的右子树高度大于它的左子树的高度
  3. 先对当前这个结点的左节点进行左旋转
  4. 在对当前结点进行右旋转的操作即可
// 添加结点的方法
	// 递归的形式添加结点，注意需要满足二叉排序树的要求
	public void add(Node node) {
		if (node == null) {
			return;
		}

		// 判断传入的结点的值，和当前子树的根结点的值关系
		if (node.value < this.value) {
			// 如果当前结点左子结点为null
			if (this.left == null) {
				this.left = node;
			} else {
				// 递归的向左子树添加
				this.left.add(node);
			}
		} else { // 添加的结点的值大于 当前结点的值
			if (this.right == null) {
				this.right = node;
			} else {
				// 递归的向右子树添加
				this.right.add(node);
			}
		}
		
		//当添加完一个结点后，如果: (右子树的高度-左子树的高度) > 1 , 左旋转
		if(rightHeight() - leftHeight() > 1) {
			//如果它的右子树的左子树的高度大于它的右子树的右子树的高度
			if(right != null && right.leftHeight() > right.rightHeight()) {
				//先对右子结点进行右旋转
				right.rightRotate();
				//然后在对当前结点进行左旋转
				leftRotate(); //左旋转..
			} else {
				//直接进行左旋转即可
				leftRotate();
			}
			return ; //必须要!!!
		}
		
		//当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
		if(leftHeight() - rightHeight() > 1) {
			//如果它的左子树的右子树高度大于它的左子树的高度
			if(left != null && left.rightHeight() > left.leftHeight()) {
				//先对当前结点的左结点(左子树)->左旋转
				left.leftRotate();
				//再对当前结点进行右旋转
				rightRotate();
			} else {
				//直接进行右旋转即可
				rightRotate();
			}
		}
	}

二叉树存在的问题？

二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿)， 就存在如下问题:

  • 1：在构建二叉树时，需要多次进行i/o操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响。
  • 2：节点海量，也会造成二叉树的高度很大，会降低操作速度.。
3、多路查找树

多路查找树的每一个节点的孩子树可以多于两个，且每个节点处可以存储多个元素。多路查找树是一种特殊的查找树，所以其元素之间存在某种特定的排序关系。

3.1、2-3树

定义2-3树中每一个节点都具有两个孩子(我们称它为2节点)或三个孩子(我们称它为3节点)。

一个2节点包含一个元素和两个孩子(只能包含两个孩子或没有孩子，不能出现有一个孩子的情况)，且与二叉排序树类似，左子树包含的元素小于该元素，右子树包含的元素大于该元素。
一个3节点包含一小一大两个元素和三个孩子(只能包含三个孩子或没有孩子，不能出现有一个孩子或有两个孩子的情况)。如果某个3节点有孩子，左子树包含小于较小元素的元素，右子树包含大于较大元素的元素，中间子树包含介于两元素之间的元素。

在这里插入图片描述

3.2、2-3-4树

和2-3树的区别就是多了四节点。

  • 2-node: 左子树比key小，右子树比key大。
  • 3-node：左子树比第一个key小；中间子树比比第一个key大，比第二个key小；右子树比第二个key大。
  • 4-node：左子树比第一个key小；第二子树比比第一个key大，比第二个key小；第三子树比第二个key大，比第三个key小；右子树比第三个key大。

在这里插入图片描述

后端技术那点事
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言数据结构算法演示(Windows版)
11-03
（1）在二叉排序树上进行查找(bstsrch)、插入结点(ins_bstree)和删除结点(del_bstree) （2）在二叉平衡树上插入结点(ins_AVLtree) 和删除结点(del_AVLtree) （3）在 B-树上插入结点(Ins_BTree) 和 删除结点(Del_...
平衡二叉树（AVL）的介绍及其左右旋转的代码实现（Java）
代码之美
10-30 697
1 平衡二叉树（AVL）的介绍 1.1 二叉排序树可能存在的问题: 对于数列{1,2,3,4,5,6}，创建一颗二叉排序树(BST)，如下图： 上图BST存在的问题分析: 左子树全部为空，从形式上看，更像一个单链表。 插入速度没有影响。 查询速度明显降低(因为需要依次比较), 不能发挥BST 的优势，因为每次还需要比较左子树，其查询速度比单链表还慢。 解决方案-平衡二叉树(AVL)。 1.2 基本介绍 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search
MySQL索引原理
热门推荐
Dobbin
02-02 3万+
B+树索引是B+树在数据库中的一种实现，是最常见也是数据库中使用最为频繁的一种索引。B+树中的B代表平衡（balance），而不是二叉（binary），因为B+树是从最早的平衡二叉树演化而来的。在讲B+树之前必须先了解二叉查找树、平衡二叉树（AVLTree）和平衡多路查找树（B-Tree），B+树即由这些树逐步优化而来。
m路搜索树,B树,B+树
宇哥的博客
03-08 2910
m路搜索树 定义:一课m路搜索树是一课空树,或者满足以下性质: (1)根节点最多有m棵子树,并具有如下数据结构: n,P0,(K1,P1),(K2,P2),....,(Kn,Pn) 其中n是关键码个数,Pi是指向子树的指针,0&lt;=i&lt;=n&lt;m,Ki是关键码,1&lt;=i&...
二叉搜索树-平衡二叉树-红黑树
aliven1的博客
06-02 331
二叉搜索树（BST，Binary Search Tree），也称为二叉排序树和二叉查找树。 二叉搜索树是一棵二叉树，可以为空。 如果不为空，则满足以下性质： 条件 1：非空左子树的所有键值小于其根节点的键值。比如三中节点 6 的所有非空左子树的键值都小于 6； 条件 2：非空右子树的所有键值大于其根节点的键值；比如三中节点 6 的所有非空右子树的键值都大于 6； 条件 3：左、右子树本身也都是二叉搜索树； 如上图所示，树二和树三符合 3 个条件属于二叉树，树一不满足条件 3 所以不是二叉树。
树结构实际应用(二叉排序树，BST，二叉搜索树)
笔记别偷看
11-04 469
11.4 二叉排序树 11.4.1 先看一个需求 给你一个数列(7, 3, 10, 12, 5, 1, 9)，要求能够高效的完成对数据的查询和添加 11.4.2 解决方案分析 使用数组 数组未排序， 优点：直接在数组尾添加，速度快。缺点：查找速度慢. [示意图] 数组排序，优点：可以使用二分查找，查找速度快，缺点：为了保证数组有序，在添加新数据时，找到插入位 置后，后面的数据需整体移动，速度慢。[示意图]  使用链式存储-链表 不管链表是否有序，查找速度都慢，添加数据速度比数组快，不需要数据整体移动。[示
【超全！】图解Java数据结构和算法(共195集)【资料+视频+课件+代码+笔记】
10-13
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫...二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分...
javabitset源码-Study:学习
06-04
二叉查找树（BST） 红黑树 B，B+，B*树 LSM 树 BitSet 常用算法 计数排序 桶排序 基数排序 二分查找 Java 中的排序工具 布隆过滤器 字符串比较 KMP 算法 深度优先、广度优先 贪心算法 回溯算法 剪枝算法 动态规划 ...
管理系统javasal源码-SQL:SQL原理及优化
06-06
最后MySql用的是B+树(多路平衡树)，为什么呢？因为对于查找来说，控制树的高度对于效率很重要，多点横向结点能存储更多的元素就可以了... 数据库查询：比如上图所示，要查找select * from T where T.col = 20 由于...
数据结构（C语言版）\Java数据结构和算
12-19
第11章 多路查找树 11.1 m-路查找树 11.2 B-树 11.3 B+树 11.4 参考文献和选读材料 第12章 数字查找结构 12.1 数字查找树 12. 2 二路Trie树和Patricia树 12.3 多路Trie树 12.4 后缀树 12.5 Trie树和互联网...
二叉排序树
小老弟的博客
07-05 2134
二叉排序树要求，在树中的任意一个节点，其左子树中的每个节点的值，都要小于这个节点的值，而右子树节点的值都大于这个节点的值，所以这么看来，二叉排序树是天然有序的，如果按照中序遍历，得到将是一个从小到大的有序数据集 删除节点 第一种情况是，如果要删除的节点没有子节点，我们只需要直接将父节点中，指向要删除节点的指针置为 null。 第二种情况是，如果要删除的节点只有一个子节点（只有左子节点或者右子节点）...
二叉树与多路树结构详解
qq_42828912的博客
12-03 347
我要带着你们一起爬树一片森林到底有多少种树追根溯源刨析各种树MyISAM储存引擎InnoDB储存引擎总结小结最后给你们推荐一本书吧 一片森林到底有多少种树 又是我，我又去充了三毛钱电费（断更好几个月）！ 追根溯源 作为一个程序员的男人，谁能不学数据结构呢，学了数据结构，你就得会爬树啊，今天我就带着你们一起爬树，我倒要看看谁在树根那站着。 刨析各种树 树的家族真的是庞大的很呦，无序树，有序树，二叉树，完全二叉树，强平衡二叉树，弱平衡二叉树，avl树，红黑树，b树，b+树。 这个思维导图是不是直观体现了树
数据结构 多路查找树 ---------B树和B+树的简单介绍
积跬步 至千里
05-17 6297
参考链接：微信公众号 程序员小灰 https://mp.weixin.qq.com/s/rDCEFzoKHIjyHfI_bsz5Rw https://mp.weixin.qq.com/s/jRZMMONW3QP43dsDKIV9VQ B树的简单介绍 前面我们已经介绍了BST AVL树 BRT，那么，为什么要B树和B+树呢？他们和之前介绍的三种树有何区别？ 其实最明显的差异体现在多叉上...
彻底搞懂这些：二叉树、平衡二叉树、B-Tree、B+Tree
stone_tmp的博客
07-03 186
背景 一般说MySQL的索引，都清楚其索引主要以B+树为主，此外还有Hash、RTree、FullText。本文简要说明一下MySQL的B+Tree索引，以及和其相关的二叉树、平衡二叉树、B-Tree，相关的知识网上很多，为了方便自己更快、清楚的了解，文本聚合一些内容以及个人的一些理解。 说明 二叉查找树（BST） 概念 二叉查找树是基于二分查找法来提高数据查找速度的二叉树的数据结构； 特点 二叉查找树是采用二分查找法把数据按规则组装成一个树形结构的数据，减少无关数据的检索，提升了数据检索的速
二叉查找树，平衡二叉树，B树，红黑树（图解）
摸金校尉的博客
04-28 1792
1、二叉查找树 二叉查找树BST（binary search/sort tree）又叫二叉搜索树或者二叉排序树，它首先是一个二叉树，而且必须满足下面的条件： 1）若左子树不空，则左子树上所有结点的值均小于它的根节点的值（左小） 2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值（右大） 3）左、右子树也分别为二叉排序树 2、平衡二叉树 平衡二叉树（AVL树)，又称自平衡...
查找 二（二叉排序树、平衡二叉树、）
Kerer的博客
07-25 522
1、二叉排序树二叉排序树又称为二叉查找树。是一个具有下列属性的二叉树： 若左子树不为空，则左子树上所有节点值均小于它的根节点的值 若右子树不为空，则右子树上所有节点的值均大于它的根节点的值 当对树进行中序遍历时，我们就会得到一个从小到大的序列。 构造二叉排序树的目的：提高查找和插入删除关键字的速度。 注意：二叉排序树中不允许有重复或相等的key值出现。1）删除操作 当删除的节点为叶子节点时，直接
数据结构与算法（七）二叉排序树，多路查找树，图
alyja的博客
08-02 301
数据结构二叉排序树二叉排序树创建和遍历平衡二叉树多路查找树图 二叉排序树 二叉排序树创建和遍历 class Node { int value; Node left; Node right; public Node(int value) { this.value = value; } @Override public String toString() { return "Node [value=" + value + "]"; } //添加结点的方法 //递归的形式
二叉排序树(二叉搜索树，二叉查找树)详细代码实现
qq_38236355的博客
04-13 1291
//二叉排序数（二叉搜索树，二叉查找树） #define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> using namespace std; #define end 32767 // 定义结束标志 //结点结构 typedef struct BiTNode { int data; struct BiTNode *lchild, *...
B树、B+树、红黑树
prefect_start的博客
05-04 6819
1、B树 B树属于多叉树又名平衡多路查找树（查找路径不只两个） 规则： （1）排序方式：所有节点关键字是按递增次序排列，并遵循左小右大原则； （2）子节点数：非叶节点的子节点数>1，且<=M ，且M>=2，空树除外（注：M阶代表一个树节点最多有多少个查找路径，M=M路,当M=2则是2叉树,M=3则是3叉）； （3）关键字数：枝节点的关键字数量大于等于ceil(m/2)-1个且小于等于M-1个（注：ceil()是个朝正无穷方向取整的函数 如ceil(1.1)结果为2); （4）所有叶子节点均
二叉查找树 平衡二叉树
最新发布
09-30
平衡二叉树是一种特殊的二叉查找树，叶节点的高度差的绝对值不超过1，并且左右子树也都是一棵平衡二叉树。平衡二叉树的目的是为了避免二叉查找树的退化情况，保持插入和查找的平均复杂度为O(log n)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值