树的常用术语
节点,树中的一个连接点
父节点,若一个节点含有子节点,则这个节点成为其子节点的父节点
子节点,一个节点含有的子树的根节点成为该节点的子节点
节点的权,节点的具体值*
节点的度,子节点的个数
路径,从根节点到某一个具体节点所走过的
层,根结点在1层,其它任一结点的层数是其父结点的层数加
子树,只要包含了一个结点,就得包含这个结点下的所有节点
高度,从根节点向下到某个叶节点最长简单路径中边的条数
树的高度,树内所有节点高度的最大值,也就是根节点的高度,也就是树的层数
二叉树
二叉树的概念
1)树有很多种,每个节点最多只能有两个子节点的一种形式称为二叉树。
2)二叉树的子节点分为左节点和右节点。
3)如果该二叉树的所有叶子节点都在最后一层,并且结点总数=2^n-1,n为层数,则我们称为满二叉树。
4)如果该二叉树的所有叶子节点都在最后一层或者倒数第二层,而且最后一层的叶子节点在左边连续,倒数第二层的叶子节点在右边连续,我们称为完全二叉树.
前序 ,中序,后序遍历
- 前序遍历:先输出父节点,再遍历左子树和右子树
- 中序遍历:先遍历左子树,再输出父节点,再遍历右子树
- 后序遍历:先遍历左子树,再遍历右子树,最后输出父节点
代码实现
package com.zhao.tree;
public class BinaryTreeDemo {
public static void main(String[] args) {
//创建树
BinaryTree tree = new BinaryTree();
Person root = new Person(1,"宋江","呼保义");
Person person1 = new Person(2,"吴用","智多星");
Person person2 = new Person(3,"卢俊义","玉麒麟");
Person person3 = new Person(4,"林冲","豹子头");
Person person4 = new Person(5,"公孙胜","入云龙");
root.setLeft(person1);
root.setRight(person2);
person2.setLeft(person4);
person2.setRight(person3);
tree.setRoot(root);
tree.preOrder();//前序遍历 1,2,3,5,4
System.out.println();
tree.infixOrder();//中序遍历 2,1,5,3,4
System.out.println();
tree.postOrder();//后序遍历 2,5,4.3.1
}
}
class BinaryTree{
private Person root;
public void setRoot(Person root) {
this.root = root;
}
//前序遍历
public void preOrder(){
if (this.root != null){
this.root.preOrder();
}else {
System.out.println("数为空");
}
}
//中序遍历
public void infixOrder(){
if (this.root != null){
this.root.infixOrder();
}else {
System.out.println("数为空");
}
}
//后序遍历
public void postOrder(){
if (this.root != null){
this.root.postOrder();
}else {
System.out.println("数为空");
}
}
}
class Person{
private int id;
private String name;
private String nickName;
private Person left; //默认为null
private Person right;//默认为null
public Person(int id, String name, String nickName) {
this.id = id;
this.name = name;
this.nickName = nickName;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public Person getLeft() {
return left;
}
public void setLeft(Person left) {
this.left = left;
}
public Person getRight() {
return right;
}
public void setRight(Person right) {
this.right = right;
}
//前序遍历
public void preOrder(){
//先输出当前节点
System.out.println(this);
//判断当前节点的左子节点不为空
if (this.left != null){
this.left.preOrder();
}
//判断当前节点的右子节点不为空
if (this.right != null){
this.right.preOrder();
}
}
//中序遍历
public void infixOrder(){
//先判断当前节点的左子节点不为空
if (this.left != null){
this.left.infixOrder();
}
//输出当前节点
System.out.println(this);
//判断当前节点的右子节点不为空
if (this.right != null){
this.right.infixOrder();
}
}
//后序遍历
public void postOrder(){
//先判断当前节点的左子节点不为空
if (this.left != null){
this.left.postOrder();
}
//再判断当前节点的右子节点不为空
if (this.right != null){
this.right.postOrder();
}
//输出当前节点
System.out.println(this);
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +
'}';
}
}
前序 ,中序,后序查找
思路分析:
代码实现
Person类
//前序查找
public Person preOrderSearch(int id){
System.out.println("找呀找");
if (this.id == id){
return this;
}
Person person = null;
if (this.left != null){
person = this.left.preOrderSearch(id);
}
if (person != null){//找到了
return person;
}
if (this.right != null){
person = this.right.preOrderSearch(id);
}
return person;
}
//中序查找
public Person infixOrderSearch(int id){
Person person = null;
//先判断当前节点的左子节点不为空
if (this.left != null){
person = this.left.infixOrderSearch(id);
}
//在判断是否查找到
if (person != null){
return person;
}
System.out.println("找呀找");
if (this.id == id){
return this;
}
if (this.right != null){
person = this.right.infixOrderSearch(id);
}
return person;
}
//后序查找
public Person postOrderSearch(int id){
Person person = null;
//先判断当前节点的左子节点不为空
if (this.left != null){
person = this.left.infixOrderSearch(id);
}
//在判断是否查找到
if (person != null){
return person;
}
if (this.right != null){
person = this.right.infixOrderSearch(id);
}
if (person != null){
return person;
}
System.out.println("找呀找");
if (this.id == id){
return this;
}
return person;
}
BinaryTree
//前序查找
public Person preOrderSearch(int id){
if (this.root != null){
return this.root.preOrderSearch(id);
}else {
return null;
}
}
//中序查找
public Person infixOrderSearch(int id){
if (this.root!=null){
return this.root.infixOrderSearch(id);
}else {
return null;
}
}
//后序查找
public Person postOrderSearch(int id){
if (this.root != null){
return this.root.postOrderSearch(id);
}else {
return null;
}
}
删除节点
要求
1)如果删除的节点是叶子节点,则删除该节点
2)如果删除的节点是非叶子节点,则删除该子树。
3)测试,删除掉5号叶子节点和3号子树。
思路分析
代码实现
Person
//删除节点
public void delete(int id){
//1.如果当前结点的左子结点不为空,并且左子结点就是要删除结点,就将this.1eft = nu1l; 并且就返回(结束递归删除)
if (this.left != null && this.left.id == id){
this.left = null;
return;
}
if (this.right != null && this.right.id == id){
this.right = null;
return;
}
if (this.left != null){
this.left.delete(id);
}
if (this.right != null){
this.right.delete(id);
}
}
BinaryTree
//删除节点
public void delete(int id){
if (this.root != null){
if (this.root.getId() == id){
this.root = null;
}else {
this.root.delete(id);
}
}else {
System.out.println("当前树为空");
}
}
顺序存储二叉
顺序存储二叉树的概念
从数据存储来看,数组存储方式和树的存储方式可以相互转换,即数组可以转换成树,树也可以转换成数组。如下图:
顺序存储二叉树的特点:
1)顺序二叉树通常只考虑完全二叉树
2)第n个元素的左子节点为 2n+1
- 第n个元素的右子节点为
2n+2
4)第n个元素的父节点为 (n-1)/ 2
- n:表示二叉树中的第几个元素(按0开始编号)
代码实现
package com.zhao.tree;
public class ArrBinaryTreeDemo {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7};
ArrBinaryTree tree= new ArrBinaryTree(arr);
System.out.println("前序遍历");//1,2,4,5,3,6,7
tree.preOrder();
System.out.println();
System.out.println("中序遍历");//4,2,5,1,6,3,7
tree.infixOrder();
System.out.println();
System.out.println("后序遍历");//4,5,2,6,7,3,1
tree.postOrder();
}
}
class ArrBinaryTree{
private int[] arr;//存储数据节点的数组
public ArrBinaryTree(int[] arr) {
this.arr = arr;
}
//方法重载
public void preOrder(){
this.preOrder(0);
}
public void infixOrder(){
this.infixOrder(0);
}
public void postOrder(){
this.postOrder(0);
}
/**
* @param index 数组的下标
*/
//前序遍历
public void preOrder(int index){
if (arr == null || arr.length == 0){
System.out.println("数组为空,无法遍历");
}
//输出当前节点值
System.out.print(arr[index]+" ");
//向左递归遍历
if ((2*index +1) < arr.length){
int num = (2*index)+1;
preOrder(num);
}
//向右递归遍历
if ((2*index +2) < arr.length){
int num = (2*index)+2;
preOrder(num);
}
}
//中序遍历
public void infixOrder(int n){
if (arr == null || arr.length == 0){
System.out.println("数组为空,无法遍历");
}
//向左递归遍历
if ((2*n +1) < arr.length){
int num = (2*n)+1;
infixOrder(num);
}
System.out.print(arr[n]+" ");
//向右递归遍历
if ((2*n +2) < arr.length){
int num = (2*n)+2;
infixOrder(num);
}
}
//中序遍历
public void postOrder(int n){
if (arr == null || arr.length == 0){
System.out.println("数组为空,无法遍历");
}
//向左递归遍历
if ((2*n +1) < arr.length){
int num = (2*n)+1;
postOrder(num);
}
//向右递归遍历
if ((2*n +2) < arr.length){
int num = (2*n)+2;
postOrder(num);
}
System.out.print(arr[n]+" ");
}
}
线索化二叉树
线索二叉树基本介绍
1)n个结点的二叉链表中含有n+1 [公式2n-(n-1)=n+1] 个空指针域。利用二叉链表中的空指针域,存放指向该结点在某种遍历次序下的前驱和后继结点的指针(这种附加的指针称为"线索")
2)这种加上了线索的二叉链表称为线索链表,相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同,线索二叉树可分为 前序线索二叉树、中序线索二叉树和后序线索二叉树三种.
3)一个结点的前一个结点,称为前驱结点
4)一个结点的后一个结点,称为后继结点
应用案例
思路分析:中序遍历的结果: {8,3,10, 1, 14, 6}
说明:当线索化二叉树后,Node节点的属性left和right,有如下情况:
1) left 指向的是左子树,也可能是指向的前驱节点 比如➊节点 left 指向的左子树,而10节点的 left 指向的就是前驱节点.
2) right指向的是右子树, 也可能是指向后继节点,比如①节点right指向的是右子树,而10节点的right指向的是后继节点.
代码实现
package com.zhao.tree;
public class ThreadedBinaryTreeDemo {
public static void main(String[] args) {
Student root = new Student(1,"呼保义宋江");
Student student = new Student(3,"智多星吴用");
Student student1 = new Student(6,"豹子头林冲");
Student student2 = new Student(8,"双鞭呼延灼");
Student student3 = new Student(10,"小旋风柴进");
Student student4 = new Student(14,"行者武松");
ThreadedBinaryTree tree = new ThreadedBinaryTree();
tree.setRoot(root);
root.setLeft(student);
root.setRight(student1);
student.setLeft(student2);
student.setRight(student3);
student1.setLeft(student4);
tree.threadedNodes();
Student left = student4.getLeft();
System.out.println("14的前驱节点为:"+left);
Student right= student4.getRight();
System.out.println("14的前驱节点为:"+right);
tree.threadedList();
}
}
class ThreadedBinaryTree{
private Student root;
//为了实现线索化,需要创建要给指向当前结点的前驱结点的指针
//在递归进行线索化时,pre总是保留前一个结点
private Student pre = null;
public void setRoot(Student root) {
this.root = root;
}
public void threadedNodes(){
this.threadedNodes(root);
}
/** 二叉树中序线索化的方法
* @param node 当前需要线索化的结点
*/
public void threadedNodes(Student node) {
if (node == null){
return;
}
//1.先线索化左子树
threadedNodes(node.getLeft());
//2线索化当前节点
//2.1处理当前节点的前驱节点
if (node.getLeft() == null){
//当前节点没有左子树就指向前驱节点
node.setLeft(pre);
//当前节点的左指针类型
node.setLeftType(1);
}
//2.2处理当前节点的后继节点(其实在下一次处理)
if (pre != null && pre.getRight() == null){
//上一个节点没有右子树,其后继节点就指向当前节点
pre.setRight(node);
pre.setRightType(1);
}
//每处理一个结点后,让当前结点是下一个结点的前驱结点
pre = node;
//再线索化右子树
threadedNodes(node.getRight());
}
//线索化遍历
public void threadedList(){
//定义一个变量,存储当前遍历的结点,从root开始
Student node = root;
while (node != null){
//循环的找到leftType == 1的结点,第一个找到就是8结点
//后面随着遍历而变化,因为当 leftType == 1时,说明该结点是按照线索化
//处理后的有效结点
while (node.getLeftType() == 0){
node = node.getLeft();
}
//打印这个节点
System.out.println(node);
//如果当前结点的右指针指向的是后继结点,就一直输出
while (node.getRightType() == 1){
//获取到当前节点的后继节点
node = node.getRight();
System.out.println(node);
}
//替换这个遍历的节点
node = node.getRight();
}
}
//删除节点
public void delete(int id){
if (this.root != null){
if (this.root.getId() == id){
this.root = null;
}else {
this.root.delete(id);
}
}else {
System.out.println("当前树为空");
}
}
//前序遍历
public void preOrder(){
if (this.root != null){
this.root.preOrder();
}else {
System.out.println("数为空");
}
}
//中序遍历
public void infixOrder(){
if (this.root != null){
this.root.infixOrder();
}else {
System.out.println("数为空");
}
}
//后序遍历
public void postOrder(){
if (this.root != null){
this.root.postOrder();
}else {
System.out.println("数为空");
}
}
//前序查找
public Student preOrderSearch(int id){
if (this.root != null){
return this.root.preOrderSearch(id);
}else {
return null;
}
}
//中序查找
public Student infixOrderSearch(int id){
if (this.root!=null){
return this.root.infixOrderSearch(id);
}else {
return null;
}
}
//后序查找
public Student postOrderSearch(int id){
if (this.root != null){
return this.root.postOrderSearch(id);
}else {
return null;
}
}
}
class Student{
private int id;
private String name;
private Student left; //默认为null
private Student right;//默认为null
private int leftType;// 0 表示指向左子树 1表示指向前驱节点
private int rightType;//0 表示指向右子树 1表示指向后继节点
public Student getLeft() {
return left;
}
public void setLeft(Student left) {
this.left = left;
}
public Student getRight() {
return right;
}
public void setRight(Student right) {
this.right = right;
}
public int getLeftType() {
return leftType;
}
public void setLeftType(int leftType) {
this.leftType = leftType;
}
public int getRightType() {
return rightType;
}
public void setRightType(int rightType) {
this.rightType = rightType;
}
public Student(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//前序遍历
public void preOrder(){
//先输出当前节点
System.out.println(this);
//判断当前节点的左子节点不为空
if (this.left != null){
this.left.preOrder();
}
//判断当前节点的右子节点不为空
if (this.right != null){
this.right.preOrder();
}
}
//中序遍历
public void infixOrder(){
//先判断当前节点的左子节点不为空
if (this.left != null){
this.left.infixOrder();
}
//输出当前节点
System.out.println(this);
//判断当前节点的右子节点不为空
if (this.right != null){
this.right.infixOrder();
}
}
//后序遍历
public void postOrder(){
//先判断当前节点的左子节点不为空
if (this.left != null){
this.left.postOrder();
}
//再判断当前节点的右子节点不为空
if (this.right != null){
this.right.postOrder();
}
//输出当前节点
System.out.println(this);
}
//前序查找
public Student preOrderSearch(int id){
System.out.println("找呀找");
if (this.id == id){
return this;
}
Student person = null;
if (this.left != null){
person = this.left.preOrderSearch(id);
}
if (person != null){//找到了
return person;
}
if (this.right != null){
person = this.right.preOrderSearch(id);
}
return person;
}
//中序查找
public Student infixOrderSearch(int id){
Student person = null;
//先判断当前节点的左子节点不为空
if (this.left != null){
person = this.left.infixOrderSearch(id);
}
//在判断是否查找到
if (person != null){
return person;
}
System.out.println("找呀找");
if (this.id == id){
return this;
}
if (this.right != null){
person = this.right.infixOrderSearch(id);
}
return person;
}
//后序查找
public Student postOrderSearch(int id){
Student person = null;
//先判断当前节点的左子节点不为空
if (this.left != null){
person = this.left.infixOrderSearch(id);
}
//在判断是否查找到
if (person != null){
return person;
}
if (this.right != null){
person = this.right.infixOrderSearch(id);
}
if (person != null){
return person;
}
System.out.println("找呀找");
if (this.id == id){
return this;
}
return person;
}
//删除节点
public void delete(int id){
//1.如果当前结点的左子结点不为空,并且左子结点就是要删除结点,就将this.1eft = nu1l; 并且就返回(结束递归删除)
if (this.left != null && this.left.id == id){
this.left = null;
return;
}
if (this.right != null && this.right.id == id){
this.right = null;
return;
}
if (this.left != null){
this.left.delete(id);
}
if (this.right != null){
this.right.delete(id);
}
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
赫夫曼树
-
给定n个权值作为n个叶子结点,构造一棵二叉树,若该树的带权路径长度(wpl)达到最小,称这样的二叉树为最优二叉树,也称为哈夫曼树(HuffmanTree),还有的书翻译为霍夫曼树。
-
赫夫曼树是带权路径长度最短的树,权值较大的结点离根较近。
赫夫曼树几个重要概念
- 路径和路径长度:在-棵树中,从一个结点往下可以达到的孩子或孙子结之间的通路,称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1,则从根结点到第L层结点的路径长度为L-1
- 结点的权及带权路径长度:若将树中结点赋给一个有着某种含义的数值,则这个数值称为该结点的权。结点的带权路径长度为:从根结点到该结点之间的路径长度与该结点的权的乘积。
- 树的带权路径长度:树的带权路径长度规定为所有叶子结点的带权路径长度之和,记为WPL(weighted path length) ,权值越大的结点离根结点越近的二叉树才是最优二叉树。
- WPL最 小的就是赫夫曼树。
代码实现
package com.zhao.tree;
import org.w3c.dom.Node;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class HuffmanTreeTest {
public static void main(String[] args) {
int[] arr = {13,7,8,3,29,6,1};
HuffmanTree huffmanTree = createHuffmanTree(arr);
preOrder(huffmanTree);
}
//创建赫夫曼树的方法
public static HuffmanTree createHuffmanTree(int[] arr){
//遍历arr数组
//将每一个元素构成一个huffman
//将huffman 放入到 ArrayList中
List<HuffmanTree> list = new ArrayList<>();
for (int value : arr){
list.add(new HuffmanTree(value));
}
while (list.size() > 1){
//排序
Collections.sort(list);
//取出根节点权值最小的两颗二叉树
HuffmanTree Left = list.get(0);
HuffmanTree Right = list.get(1);
//构建一颗新的二叉树
HuffmanTree parent = new HuffmanTree(Left.value+Right.value);
parent.left = Left;
parent.right = Right;
//从list中删除处理过的二叉树
list.remove(Left);
list.remove(Right);
//将parent加入到list
list.add(parent);
}
return list.get(0);
}
public static void preOrder(HuffmanTree root){
if (root != null){
root.preOrder();
}else {
System.out.println("赫夫曼树为空!");
}
}
}
class HuffmanTree implements Comparable<HuffmanTree>{
public int value;//结点权值
public HuffmanTree left;//左子节点
public HuffmanTree right;//右子节点
//中序遍历
public void preOrder(){
System.out.println(this);
if (this.left != null){
this.left.preOrder();
}
if (this.right != null){
this.right.preOrder();
}
}
public HuffmanTree(int value) {
this.value = value;
}
@Override
public int compareTo(HuffmanTree o) {
return this.value - o.value;//从小到大
}
@Override
public String toString() {
return "HuffmanTree{" +
"value=" + value +
'}';
}
}
二叉排序树
二叉排序树:BST: (Binary Sort(Search) Tree)
,对于二叉排序树的任何一个非叶子节点,要求左子节点的值比当前节点的值小,右子节点的值比当前节点的值大。特别说明:如果有相同的值,可以将该节点放在左子节点或右子节点。
代码实现:
package com.zhao.tree;
public class BinarySortTreeDemo {
public static void main(String[] args) {
int[] arr = {7,3,10,12,5,1,9};
BinarySortTree tree = new BinarySortTree();
for (int i = 0; i < arr.length; i++) {
tree.add(new Node(arr[i]));
}
tree.preOrder();
}
}
class BinarySortTree{
private Node root;//根节点
//添加
public void add(Node node){
if (root == null){
root = node;
}else{
root.add(node);
}
}
//遍历
public void preOrder(){
if (root == null){
System.out.println("二叉排序树为空,无法遍历");
}else {
root.preOrder();
}
}
}
class Node{
public int value;
public Node left;
public Node right;
public Node(int value) {
this.value = value;
}
//添加
public void add(Node node){
if (node == null){
return;
}
//判断传入结点的值,和当前子树的根节点的值的关系
if (node.value < this.value){
//如果当前节点的左子节点为空
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 preOrder(){
if (this.left != null){
this.left.preOrder();
}
System.out.println(this);
if (this.right != null){
this.right.preOrder();
}
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
}
删除二叉排序树的结点
二叉排序树的删除情况比较复杂,有下面三种情况需要考虑
1)删除叶子节点(比如: 2, 5, 9, 12)
2)删除只有一颗子树的节点(比如: 1)
3)删除有两颗子树的节点.(比如: 7, 3,10)
思路分析:
代码实现
package com.zhao.tree;
public class BinarySortTreeDemo {
public static void main(String[] args) {
int[] arr = {7,3,10,12,5,1,9,0};
BinarySortTree tree = new BinarySortTree();
for (int i = 0; i < arr.length; i++) {
tree.add(new Node(arr[i]));
}
tree.preOrder();
tree.delNode(7);
tree.delNode(3);
tree.delNode(1);
tree.delNode(12);
tree.delNode(5);
tree.delNode(10);
tree.delNode(9);
tree.delNode(0);
System.out.println("删除后:");
tree.preOrder();
}
}
class BinarySortTree{
private Node root;//根节点
//添加
public void add(Node node){
if (root == null){
root = node;
}else{
root.add(node);
}
}
//查找要删除的结点
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);
}
}
/**
* 获取以传入节点为根节点的最小值
* @param right (可以当作二叉排序树的根节点)
* @return 返回最小节点的值
*/
public int delRightMin(Node right){
Node temp = right;
while (temp.left != null){
temp = temp.left;
}
//删除最小结点
delNode(temp.value);
return temp.value;
}
/**
* 获取以传入节点为根节点的最大值
* @param left (可以当作二叉排序树的根节点)
* @return 返回最大节点的值
*/
public int delLeftMax(Node left){
Node temp = left;
while (temp.right != null){
temp = temp.right;
}
//删除最小结点
delNode(temp.value);
return temp.value;
}
//删除节点
public void delNode(int value){
if (root == null){
return;
}else {
//找到要删除的结点
Node search = search(value);
if (search == null){
return;
}
//如果这颗树只有一个结点,并且就是要删除的结点
if (root.right == null && root.left==null){
root = null;
return;
}
//找到要删除结点的父节点
Node parent = searchParent(value);
//如果要删除的结点为叶子结点
if (search.left == null && search.right == null){
//判断search是父节点的左子节点还是右子节点
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 (search.right != null && search.left != null){//删除有两颗子树的结点
int min = delRightMin(search.right);
search.value = min;
//左子树的最大值
// int max = delLeftMax(search.left);
// search.value = max;
}else {//删除只有一颗子树的结点
if (search.left != null){//如果要删除的结点有左子结点
if (parent != null){
if (parent.left.value == value){//search是parent的左子节点
parent.left = search.left;
}else {//search是parent的右子节点
parent.right = search.left;
}
}else {
root = search.left;
}
}else{//如果要删除的结点有右子结点
if (parent != null){
if (parent.left.value == value){//search是parent的左子节点
parent.left = search.right;
}else {//search是parent的右子节点
parent.right = search.right;
}
}else {
root = parent.right;
}
}
}
}
}
//遍历
public void preOrder(){
if (root == null){
System.out.println("二叉排序树为空,无法遍历");
}else {
root.preOrder();
}
}
}
class Node{
public int value;
public Node left;
public Node right;
public Node(int value) {
this.value = value;
}
//添加
public void add(Node node){
if (node == null){
return;
}
//判断传入结点的值,和当前子树的根节点的值的关系
if (node.value < this.value){
//如果当前节点的左子节点为空
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 preOrder(){
if (this.left != null){
this.left.preOrder();
}
System.out.println(this);
if (this.right != null){
this.right.preOrder();
}
}
//找到要删除的结点
public Node search(int value){
//如果当前节点的值等于要查找的值
if (value == this.value){
return this;
}else if (value < this.value){//如果要查找的值小于当前结点的值
//当前节点的左子节点为空,则返回null
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
*/
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 +
'}';
}
}
平衡二叉树
基本介绍
- 平衡二叉树也叫平衡二叉搜索树又被称为AVL树,可以保证查询效率较高。
- 具有以下特点:它是一棵空树或他的两个子树的高度差的绝对值不超过1,并且左右两个子树都是一个平衡二叉树。平衡二叉树的常用实现方法有红黑树,AVL,替罪羊树,Treap,伸展树等。
左旋转
思路分析:
1.创建一个新的节点newNode (以4这个值创建),值等于当前根节点的值
2.把新节点的左子树设置了当前节点的左子newNode.left = left
3.把新节点的右子树设置为当前节点的右子树的左子树newNode.right =right.left;
4.把当前节点的值换为右子节点的值value=right.value
5.把当前节点的右子树设置成当前节点的右子树的右子树right=right.right
6.把当前节点的左子树设置为新节点left=newLeft
代码实现
//左旋转的方法
private void leftRotate(){
//创建一个新的节点newNode ,值等于当前根节点的值
Node newNode = new Node(value);
//把新节点的左子树设置了当前节点的左子结点
newNode.left = left;
//把新节点的右子树设置为当前节点的右子结点的左子树
newNode.right = right.left;
//把当前节点的值换为右子节点的值
value = right.value;
//把当前节点的右子树设置成当前节点的右子结点的右子树
right = right.right;
//把当前节点的左子树设置为新节点
left = newNode;
}
右旋转
1.创建一个新的节点newNode(以10这个值创建),值等于当前根节点的值
2.把新节点的右子树设置了当前节点的右子树newNode.right = right
3.把新节点的左子树设置为当前节点的左子结点的右子树newNode.left =left.right
4.把当前节点的值换为左子节点的value=left.value
5.把当前节点的左子树设置成左子结点的左子树left=left.left
6.把当前节点的右子树设置为新节点right=newLeft
代码实现
//右旋转的方法
private void rightRotate(){
Node newNode = new Node(value
newNode.right = right;
newNode.left = left.right;
value = left.value;
left = left.left;
right = newNode;
}
双旋转
- 右旋转
- 当符号右旋转的条件时
- 如果它的左子结点的右子树高度大于它的左子树的高度
- 先对当前这个结点的左节点进行左旋转
- 在对当前结点进行右旋转的操作即可
- 左旋转
- 当符号左旋转的条件时
- 如果它的右子结点的左子树高度大于它的右子树的高度
- 先对当前这个结点的右节点进行右旋转
- 在对当前结点进行左旋转的操作即可
代码实现
package com.zhao.avl;
public class AVLTreeDemo {
public static void main(String[] args) {
//int[] arr = {10,11,7,6,8,9};
int[] arr = {2,1,6,5,7,3};
AVLTree avlTree = new AVLTree();
for (int i = 0; i < arr.length; i++) {
avlTree.add(new Node(arr[i]));
}
System.out.println("中序遍历");
avlTree.preOrder();
System.out.println("平衡后的树");
System.out.println("树的高度"+avlTree.getRoot().Height());
System.out.println(avlTree.getRoot());
System.out.println("树的左子树的高度"+avlTree.getRoot().LeftHeight());
System.out.println("树的右子树的高度"+avlTree.getRoot().RightHeight());
}
}
class AVLTree{
private Node root;//根节点
public Node getRoot() {
return root;
}
//添加
public void add(Node node){
if (root == null){
root = node;
}else{
root.add(node);
}
}
//查找要删除的结点
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);
}
}
/**
* 获取以传入节点为根节点的最小值
* @param right (可以当作二叉排序树的根节点)
* @return 返回最小节点的值
*/
public int delRightMin(Node right){
Node temp = right;
while (temp.left != null){
temp = temp.left;
}
//删除最小结点
delNode(temp.value);
return temp.value;
}
/**
* 获取以传入节点为根节点的最大值
* @param left (可以当作二叉排序树的根节点)
* @return 返回最大节点的值
*/
public int delLeftMax(Node left){
Node temp = left;
while (temp.right != null){
temp = temp.right;
}
//删除最小结点
delNode(temp.value);
return temp.value;
}
//删除节点
public void delNode(int value){
if (root == null){
return;
}else {
//找到要删除的结点
Node search = search(value);
if (search == null){
return;
}
//如果这颗树只有一个结点,并且就是要删除的结点
if (root.right == null && root.left==null){
root = null;
return;
}
//找到要删除结点的父节点
Node parent = searchParent(value);
//如果要删除的结点为叶子结点
if (search.left == null && search.right == null){
//判断search是父节点的左子节点还是右子节点
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 (search.right != null && search.left != null){//删除有两颗子树的结点
int min = delRightMin(search.right);
search.value = min;
//左子树的最大值
// int max = delLeftMax(search.left);
// search.value = max;
}else {//删除只有一颗子树的结点
if (search.left != null){//如果要删除的结点有左子结点
if (parent != null){
if (parent.left.value == value){//search是parent的左子节点
parent.left = search.left;
}else {//search是parent的右子节点
parent.right = search.left;
}
}else {
root = search.left;
}
}else{//如果要删除的结点有右子结点
if (parent != null){
if (parent.left.value == value){//search是parent的左子节点
parent.left = search.right;
}else {//search是parent的右子节点
parent.right = search.right;
}
}else {
root = parent.right;
}
}
}
}
}
//遍历
public void preOrder(){
if (root == null){
System.out.println("二叉排序树为空,无法遍历");
}else {
root.preOrder();
}
}
}
class Node{
public int value;
public Node left;
public Node right;
public Node(int value) {
this.value = value;
}
//返回当前节点的高度
public int Height(){
return Math.max(left == null ? 0 : left.Height(),right == null ? 0 : right.Height()) + 1;
}
//返回当前节点的左子树的高度
public int LeftHeight(){
if (left == null){
return 0;
}
return left.Height();
}
//返回当前节点的右子树的高度
public int RightHeight(){
if (right == null){
return 0;
}
return right.Height();
}
//左旋转的方法
private void leftRotate(){
//创建一个新的节点newNode ,值等于当前根节点的值
Node newNode = new Node(value);
//把新节点的左子树设置了当前节点的左子结点
newNode.left = left;
//把新节点的右子树设置为当前节点的右子结点的左子树
newNode.right = right.left;
//把当前节点的值换为右子节点的值
value = right.value;
//把当前节点的右子树设置成当前节点的右子结点的右子树
right = right.right;
//把当前节点的左子树设置为新节点
left = newNode;
}
//右旋转的方法
private void rightRotate(){
Node newNode = new Node(value);
newNode.right = right;
newNode.left = left.right;
value = left.value;
left = left.left;
right = newNode;
}
//添加
public void add(Node node){
if (node == null){
return;
}
//判断传入结点的值,和当前子树的根节点的值的关系
if (node.value < this.value){
//如果当前节点的左子节点为空
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);
}
}
//当添加完一个节点后,如果满足左旋转的条件
if (RightHeight() - LeftHeight() > 1){
if (right != null && right.LeftHeight() > right.RightHeight()){
right.rightRotate();
leftRotate();
}else {
leftRotate();//左旋转
}
}
//当添加完一个节点后,如果满足右旋转的条件
if (LeftHeight() - RightHeight()> 1){
//如果它的左子结点的右子树高度大于它的左子树的高度
if (left != null && left.RightHeight() > left.LeftHeight()){
//先对当前这个结点的左节点进行左旋转
left.leftRotate();
rightRotate();
}else {
rightRotate();//右旋转
}
}
}
//中序遍历
public void preOrder(){
if (this.left != null){
this.left.preOrder();
}
System.out.println(this);
if (this.right != null){
this.right.preOrder();
}
}
//找到要删除的结点
public Node search(int value){
//如果当前节点的值等于要查找的值
if (value == this.value){
return this;
}else if (value < this.value){//如果要查找的值小于当前结点的值
//当前节点的左子节点为空,则返回null
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
*/
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 +
'}';
}
}
B树,B+树
B树
- B树的阶:节点的最多子节点个数。比如2-3树的阶是3,2-3-4树的阶是4
- B-树的搜索,从根结点开始,对结点内的关键字(有序)序列进行二分查找,如果命中则结束,否则进入查询关键字所属范围的儿子结点:重复,直到所对应的儿子
指针为空,或已经是叶子结点 - 关键字集合分布在整颗树中,即叶子节点和非叶子节点都存放数据.
- 搜索有可能在非叶子结点结束
- 其搜索性能等价于在关键字全集内做一次二分查找
B+树
B+树是B树的变体,也是一种多路搜索树
- B+树的搜索与B树也基本相同,区别是B+树只有达到叶子结点才命中(B树可以在非叶子结点命中) ,其性能也等价于在关键字全集做一次二分查找
- 所有关键字都出现在叶子结点的链表中(即数据只能在叶子节点
稠密索引]
,且链表中的关键字(数据)恰好是有序的。 - 不可能在非叶子结点命中
- 非叶子结点相当于是叶子结点的索引
稀疏索引
,叶子结点相当于是存储(关键字)数据的数据层更适合文件索引系统 - B树和B+树各有自己的应用场景,不能说B+树完全比B树好,反之亦然.
B*树
B*树是B+树的变体,在B+树的非根和非叶子结点再增加指向兄弟的指针.
- 树定义了非叶子结点关键字个数至少为(2/3)M,即块的最低使用率为2/3,而B+树的块的最低使用率为B+树的1/2。
- 从第1个特点我们可以看出,B树分配新结点的概率比B+树要低,空间使用率更高