二叉树，二叉查找树，AVL树的一种实现

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量253 收藏
点赞数 1
分类专栏： 二叉树 文章标签： java 算法 二叉树 数据结构 avl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_LICY/article/details/104735594
版权

二叉树，二叉查找树，平衡二叉树，AVL树的一种实现

	网上关于二叉树的介绍有很多，这里不做多介绍，今天给大家分享一个自己实现的二叉查找树和AVL树。其实AVL树只是
比二叉查找树多一步平衡，后面会单独介绍平衡方法。

1、首先构建一个AvlNode。

public class AvlNode {
    //节点
    public int element;
    //左子树
    public AvlNode left;
    //右子树
    public AvlNode right;
    //树高
    public int height;
    public AvlNode(int theElement) {
        this(theElement, null, null);
    }
    public AvlNode(int theElement, AvlNode lt, AvlNode rt) {
        this.element = theElement;
        this.left = lt;
        this.right = rt;
        this.height = 0;
    }
}

2、insert方法

public AvlNode insert(int element, AvlNode avlNode, boolean isBalance) {
	if (avlNode == null) {
		return new AvlNode(element, null, null);
	}
	int compareResult = element - avlNode.element;
	if (compareResult < 0) {
		avlNode.left = insert(element, avlNode.left, isBalance);
	} else if (compareResult > 0) {
		avlNode.right = insert(element, avlNode.right, isBalance);
	} else { //相等，do nothing
		;
	}
	return isBalance ? balance(avlNode) : avlNode;
}

1、element是要插入的元素，avlNode是要往这个节点下插入元素。
2、isBalance=true，则构建AVL树，isBalance=false则构建二叉查找树。
3、当AvlNode == null，则构建新节点返回。否则，若元素小于当前节点，则往左节点插入；若大于当前节点，则往右节点插入；若相等，则不进行任何处理。
4、到这一步，二叉查找树构建完毕，若是需要构建AVL树，则需要进行平衡。

3、平衡方法（balance）

private AvlNode balance(AvlNode avlNode) {
	if (avlNode == null) {
		return avlNode;
	}
	if (getHeight(avlNode.left) - getHeight(avlNode.right) > BALANCE_FACTOR) {
		if (getHeight(avlNode.left.left) >= getHeight(avlNode.left.right)) {
			avlNode = leftLeftRotate(avlNode);
		} else {
			avlNode = leftRightRotate(avlNode);
		}
	} else if (getHeight(avlNode.right) - getHeight(avlNode.left) > 1) {
		if (getHeight(avlNode.right.right) >= getHeight(avlNode.right.left)) {
			avlNode = rightRightRotate(avlNode);
		} else {
			avlNode = rightLeftRotate(avlNode);
		}
	}
	avlNode.height = Math.max(getHeight(avlNode.left), getHeight(avlNode.right)) + 1;
	return avlNode;
}

1、BALANCE_FACTOR：平衡因子为1。
2、假设当前节点为root，左子树为L，右子树为R。
若左子树（L）的高减去右子树（R）的高大于平衡因子，则比较左子树的左右子树。
（1）若L.left的高大于L.right的高，则满足LL情况，需要进行右单旋。
（2）若L.left的高小于L.right的高，则满足LR情况，需要两次旋转（先左单旋，再右单旋）。
若右子树（R）的高减去左子树（L）的高大于平衡因子，则比较右子树的左右子树。
（1）若R.right的高大于R.left的高，则满足RR情况，需要进行左单旋。
（2）若R.right的高小于R.left的高，则满足RL情况，需要两次旋转（先右单旋，再左单旋）。
重新计算当前节点的高。

4、 四种旋转（LL、RR、LR、RL）

/**
 * 左左情况，右单旋
 * @param avlNode
 * @return
 */
private AvlNode leftLeftRotate(AvlNode avlNode) {
	AvlNode left = avlNode.left;
	avlNode.left = left.right;
	left.right = avlNode;
	avlNode.height = Math.max(getHeight(avlNode.left), getHeight(avlNode.right)) + 1;
	left.height = Math.max(getHeight(left.left), getHeight(left.right)) + 1;
	return left;
}

/**
 * 右右旋转，左单旋
 * @param avlNode
 * @return
 */
private AvlNode rightRightRotate(AvlNode avlNode) {
	AvlNode right = avlNode.right;
	avlNode.right = right.left;
	right.left = avlNode;
	avlNode.height = Math.max(getHeight(avlNode.left), getHeight(avlNode.right)) + 1;
	right.height = Math.max(getHeight(right.left), getHeight(right.right)) + 1;
	return right;
}

/**
 * 左右情况，先用左子树进行左单旋，自己再进行右单旋
 * @param avlNode
 * @return
 */
private AvlNode leftRightRotate(AvlNode avlNode) {
	avlNode.left = rightRightRotate(avlNode.left);
	return leftLeftRotate(avlNode);
}

/**
 * 右左情况，先用右子树进行右单旋，自己再进行左单旋
 * @param avlNode
 * @return
 */
private AvlNode rightLeftRotate(AvlNode avlNode) {
	avlNode.right = leftLeftRotate(avlNode.right);
	return rightRightRotate(avlNode);
}

5、二叉树的删除

/**
 * 
 * @param element
 * @param avlNode
 * @return
 */
public AvlNode remove(int element, AvlNode avlNode) {
	if (avlNode == null) {
		return avlNode;
	}
	int compareResult = element - avlNode.element;
	if (compareResult < 0) {
		avlNode.left = remove(element, avlNode.left);
	} else if (compareResult > 0) {
		avlNode.right = remove(element, avlNode.right);
	} else if (avlNode.left != null && avlNode.right != null) {
		avlNode.element = findMin(avlNode.right).element;
		avlNode.right = remove(avlNode.element, avlNode.right);
	} else {
		avlNode = avlNode.left != null ? avlNode.left : avlNode.right;
	}
	return balance(avlNode);
}

/**
 * 找到最小节点
 * @param avlNode
 * @return
 */
private AvlNode findMin(AvlNode avlNode) {
	if (avlNode == null) {
		return null;
	} else if (avlNode.left == null) {
		return avlNode;
	}
	return findMin(avlNode.left);
}

1、将要删除的元素和当前节点元素进行对比，若小于当前节点，则去左子树递归删除，若大于当前节点则去右子树递归删除。
2、若是等于当前节点。
（1）当前节点的左右子树都不为空，则需要找到右子树最小的节点，将最小节点的元素放到当前节点。然后递归删除最小节点。
（2）若当前节点左右子树有一个为空，左子树不为空，则返回左子树，否则返回右子树。

6、二叉树的打印

/**
 * 直接调用打印方法，用长度为100的数组来存放二叉树
 * @param root
 */
public void printAvlTree(AvlNode root) {
	printAvlTreeWithLength(root, 100);
}

/**
 * 指定数组长度来存放二叉树
 * @param root
 * @param length
 */
public void printAvlTreeWithLength(AvlNode root, int length) {
	List<AvlNode> list1 = new LinkedList<>();
	List<AvlNode> list2 = new LinkedList<>();
	list1.add(root);
	int[] avls = generateAvls(new int[length], root, 0, length);
	Map<String, String> flagMap = new HashMap<>();
	flagMap.put("flag", "N");
	printAvlByRecurion(avls, list1, list2, flagMap);
}

/**
 * 递归打印方法
 * @param avls
 * @param list1
 * @param list2
 * @param flagMap
 */
private void printAvlByRecurion(int[] avls, List<AvlNode> list1, List<AvlNode> list2, Map<String, String> flagMap) {
	if (list1.isEmpty() && list2.isEmpty()) {
		return;
	}
	if (!list1.isEmpty()) {
		String[] printAvls = new String[avls.length];
		while (!list1.isEmpty()) {
			AvlNode avlNode = list1.remove(0);
			//将父节点放入到打印数组中
			int parentIndex = getIndex(avlNode, avls);
			printAvls[parentIndex] = String.valueOf(avlNode.element);
			if (avlNode.left != null) {
				list2.add(avlNode.left);
				int leftIndex = getIndex(avlNode.left, avls);
				generatePrivateAvls(leftIndex, parentIndex - 1, printAvls);
			}
			if (avlNode.right != null) {
				list2.add(avlNode.right);
				int rightIndex = getIndex(avlNode.right, avls);
				generatePrivateAvls(parentIndex + 1, rightIndex, printAvls);
			}
		}
		printAvlsByString(printAvls, flagMap);
		printAvlByRecurion(avls, list1, list2, flagMap);
	}
	if (!list2.isEmpty()) {
		String[] printAvls = new String[avls.length];
		while (!list2.isEmpty()) {
			AvlNode avlNode = list2.remove(0);
			//将父节点放入到打印数组中
			int parentIndex = getIndex(avlNode, avls);
			printAvls[parentIndex] = String.valueOf(avlNode.element);
			if (avlNode.left != null) {
				list1.add(avlNode.left);
				int leftIndex = getIndex(avlNode.left, avls);
				generatePrivateAvls(leftIndex, parentIndex - 1, printAvls);
			}
			if (avlNode.right != null) {
				list1.add(avlNode.right);
				int rightIndex = getIndex(avlNode.right, avls);
				generatePrivateAvls(parentIndex + 1, rightIndex, printAvls);
			}
		}
		printAvlsByString(printAvls, flagMap);
		printAvlByRecurion(avls, list1, list2, flagMap);
	}
}

/**
 * 将构建好的数组打印
 * @param avls
 * @param flagMap
 */
private void printAvlsByString(String[] avls, Map<String, String> flagMap) {
	for (int i = 0; i < avls.length; i++) {
		if (avls[i] != null && !avls[i].equals("-")) {
			if ("Y".equals(flagMap.get("flag"))) {
				System.out.print("|");
			}
		} else {
			System.out.print(" ");
		}
	}
	flagMap.put("flag", "Y");
	System.out.println();
	for (int i = 0; i < avls.length; i++) {
		if (avls[i] != null) {
			System.out.print(avls[i]);
		} else {
			System.out.print(" ");
		}
	}
	System.out.println();
}

/**
 * 用于构建左右子树的连接
 * @param startIndex
 * @param endIndex
 * @param avls
 */
private void generatePrivateAvls(int startIndex, int endIndex, String[] avls) {
	for (int i = startIndex; i <= endIndex; i++) {
		avls[i] = "-";
	}
}

/**
 * 获取当前元素在数组里的索引
 * @param avlNode
 * @param avls
 * @return
 */
private int getIndex(AvlNode avlNode, int[] avls) {
	for (int i = 0; i < avls.length; i++) {
		if(avlNode.element == avls[i]) {
			return i;
		}
	}
	return -1;
}

主体思想：按层打印，先将第一层的节点放入到list1，然后取出打印，同时每取出一个节点然后将其左右节点放入到另一个list2。然后递归。

7、测试类以及效果

public class AvlTest {
    public static void main(String[] args) {
        int[] elements = {15, 8, 20, 4, 10, 25, 3, 5, 9, 11, 12};

        AvlService service = new AvlService();
        AvlNode root = null;
        System.out.println("二叉查找树");
        for (int element:elements) {
            root = service.insert(element, root, false);
        }
        service.printAvlTree(root);
        root = null;
        System.out.println("平衡二叉树");
        for (int element:elements) {
            root = service.insert(element, root, true);
        }
        service.printAvlTree(root);
        int e = 9;
        System.out.println("删除节点：" + e);
        root = service.remove(e, root);
        service.printAvlTree(root);

    }
}

在这里插入图片描述
项目源码：
github：https://github.com/licy-IT/Tree.git
码云：https://gitee.com/rising-dragon/Tree.git

csdn_LICY
关注
专栏目录
树、二叉树、AVL树
baiqishijkh的博客
11-21 879
树、二叉树、AVL树                                                                                                                                                                   (注：本文转自http://www.cnblogs
一步一步写平衡二叉树（AVL树）
weixin_30588907的博客
08-20 572
一步一步写平衡二叉树（AVL树） 作者：C小加 更新时间：2012-8-20 　　平衡二叉树（Balanced Binary Tree）是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。1962年，G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树，所以它又叫AVL树。平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一个节...
数据结构—二叉查找树和AVL树
杨建军的博客
05-20 594
一、二叉查找树1、概念：二、AVL树
二叉查找树与平衡二叉树
热门推荐
金发只是水一下的博客
08-29 8万+
二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 　　如上图所示，是不同形态...
一看就懂的二叉查找树和平衡二叉查找树
weixin_46272350的博客
10-04 1691
二叉查找树是一种特殊的二叉树，它可以组织动态数据集合，可以支持数据的快速插入，删除和查找操作。之前我们讨论过哈希表，他的，查找，插如和删除的时间复杂度是O(1)，既然哈希表这么高效，那么为什么还需要二叉查找树呢？ 二叉查找树的定义和操作 二叉查找树是二叉树中一种常用的一种类型。二叉查找树是为了实现快速查找产生的。不过，它不仅支持快速查找，还支持快速插入和删除。这主要归功于二叉查找树的一个特性，那就是树中任一节点，这个节点的左子树的值总是小于这个节点的值，这个节点右子树的值总是大于这个节点的值，.
【十二】数据结构之树、二叉树、二叉查找树、平衡二叉查找树AVL、红黑树、B树、B+树简介
Sid小杰的博客
03-18 1895
树 二叉树 二叉查找树 平衡二叉树 红黑树 B树
二叉树，二叉查找树，平衡二叉树以及红黑树概述
yilulvxing的博客
07-05 9303
在这篇博客之前，花了些时间了解红黑树的内容，但是没有形成自己的知识图谱，也没有一条清晰的逻辑主线将知识串联起来，这次重新整理了一下。 首先，这里过滤了树模型的一些基础概念上的内容，比如父节点，子节点，叶子节点（叶节点），兄弟节点，树的深度，树的高度，树的层数等，在这篇博客中没有叙述。 首先以最基本的二叉树开始，由浅入深，逐渐了解各个算法的优缺点适用场景，可以解决什么样的问题，优缺点有哪些，实现权衡...
二叉树与二叉搜索树
数据工匠记
07-15 1687
本文将从二叉树、二叉搜索树的定义和性质入手，通过代码实现深度认识二分搜索树。 什么是二叉树？ 在我们的现实场景中，比如图书馆我们可以根据分类快速找到我们想要找到的书籍。比如我们要找一本叫做《Java编程思想》这本书，我们只需要根据理工科 —> 计算机 —>Java语言分区就可以快速找到我们想要的这本书。这样我们就不需要像数组或者链表这种结构，我们需要遍历一遍才能找到我们想要的东西。再比如，我们所使用的电脑的文件夹目录本身也是一种树的结构。 从上面的描述我们可知，树这种结构具备天然的高效性可以巧妙
数据结构中的几棵树——二叉树、二叉查找树、AVL、多路查找树
NewB20143864的博客
03-14 326
文章目录1.二叉树2.二叉搜索树（BST）3.平衡二叉树（AVL树）4.多路查找树4.1 2-3树4.2 2-3-4树4.3 B树4.4 B+树   本篇总结一下数据结构中的几种树形结构，包括二叉树、线索二叉树、二叉查找树、平衡二叉树（AVL）、多路查找树（B树）、B+树。 1.二叉树 定义：二叉树（Binary Tree）是n（大于等于0）个结点的有限集合，该集合或为空，或由一个根结点和两棵互...
二叉查找树的编程与实现 C语言
timerring的博客
07-10 5万+
输入数据的第一行为一个正整数T，表示测试数据的组数，即共 T 组测试数据。每组测试数据的第一行输入正整数 n(5 ≤n ≤20)，第二行输入n个整数，要求依次完成以下工作：1）以这n个整数生成一棵用链式存储结构存储的二叉排序树2）按递增顺序输出该二叉排序树中所有数3）输入一个整数key ，对该二叉排序树进行查找，若在该二叉排序树中存在这个整数key ，则输出find ，否则输出not find；4）输入一个整数key，若该二叉排序树中不存在这个整数key，则将key 插入到该二叉排序树中，使插入后仍为原性质
二叉查找树+AVL树.zip
03-11
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它具有以下特性：每个节点包含一个键（key）、一个关联的值、一个指向左子节点的引用和一个指向右子节点的引用。在二叉查找树中，对于任意节点，...
二叉树和二叉查找树-基本方法.pdf
03-14
二叉查找树（Binary Search Tree，简称BST）是二叉树的一种特殊形式，它具有以下特性： 1. 每个节点的左子树仅包含比节点小的元素。 2. 每个节点的右子树仅包含比节点大的元素。 3. 左右子树也必须分别是二叉查找树...
数据结构-用户登录实验-二叉查找树AVL树实现
05-23
首先，二叉查找树是一种特殊的二叉树，其中每个节点包含一个键、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的所有节点的键都小于该节点的键，而右子树中...
二叉查找树(BST)，平衡二叉树(AVL)，红黑树之间的区别
Linkai12138的博客
10-14 1546
1. 4者的区别与联系 二叉树，二叉查找树(BST)，平衡二叉树(AVL)，红黑树之间的区别： 根据百度百科给出的定义，它们之间的关系可以用下图表示，平衡二叉树（平衡二叉查找树，AVL）和红黑树都是二叉查找树的一种，区别就是平衡二叉树严格平衡，红黑树是弱平衡。 而AVL树由于实现比较复杂，而且插入和删除性能差，在实际环境下的应用不如红黑树。 2. 二叉查找树（BST） 2.1 定义 左子树的值小于根节点的值，右子树的值全部大于根节点的值；左右子树分别都是一颗二叉查找树。（递归定义） 3.1.2 缺点 可
Java企业面试题3
最新发布
m0_74972727的博客
09-15 261
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 564
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Gradle
xiaocaij_icai的博客
09-15 110
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 882
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Spring AMQP给消息添加头信息
yong472727322的博客
09-10 303
【代码】Spring AMQP给消息添加头信息。
二叉查找树实现的集合分析与优缺点探讨
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值