对树结构的学习

树的常用术语

节点，树中的一个连接点

父节点，若一个节点含有子节点，则这个节点成为其子节点的父节点

子节点，一个节点含有的子树的根节点成为该节点的子节点

节点的权，节点的具体值*

节点的度，子节点的个数

路径，从根节点到某一个具体节点所走过的

层，根结点在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

3. 第n个元素的右子节点为2n+2

4)第n个元素的父节点为 (n-1)/ 2

5. 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 +
                '}';
    }
}

平衡二叉树

基本介绍

1. 平衡二叉树也叫平衡二叉搜索树又被称为AVL树，可以保证查询效率较高。
2. 具有以下特点：它是一棵空树或他的两个子树的高度差的绝对值不超过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+树要低，空间使用率更高