数据结构之二叉树

---

前言

首先介绍一下树与二叉树的基本概念：
       树：能提高数据存储和读取的能力
       树的常用术语： 根节点：没有父节点的节点为根节点
                                 父节点，子节点，层，子树，
                                 叶子节点：没有子节点的节点
                                 节点的权：节点内部存储的值；
                                 路径：从根节点找到该节点的路径；
                                 树的高度：树的最大层；森林：多个子树构成森林
      二叉树：
                二叉树的子节点分为左节点和右节点
      满二叉树：
                如果该二叉树的所有叶子节点都在最后一层，并且节点总数为
                 2^n-1，n为层数，则我们成为满二叉树。
      完全二叉树：
                 如果所有叶子节点都在最后一层或者倒数第二层，而且最后一层
                 的叶子节点在左边连续，倒数第二层的叶子节点数在右边连续。

---

一、二叉树的遍历

(1) 二叉树遍历的分类：
            1.前序遍历：先输出父节点，再遍历左子树和右子树
            2.中序遍历：先遍历左子树，再输出父节点，再遍历右子树
            3.后序遍历：先遍历左子树，再遍历右子树，最后输出父节点
(2) 二叉树遍历的思路分析：
            1.前序遍历：1.1先输出当前节点
                                 1.2如果左子节点不为空，则向左继续前序遍历
                                 1.3如果右子节点不为空，则向右继续前序遍历
            2.中序遍历：2.1先判断左子节点不为空，向左递归继续中序遍历
                                 2.2输出当前节点
                                 2.3判断右子节点不为空，则向右继续中序遍历
            3.后序遍历：3.1先判断左子节点不为空，向左递归继续后序遍历
                                 3.2再判断右子节点不为空，则向右继续后序遍历
                                 3.3最后输出当前节点

二叉树遍历的代码实现

package com.shangguigu.javase.binarytree;

public class BinaryTreeTest {
    public static void main(String[] args) {
        //创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        HeroNode heroNode1 = new HeroNode(1,"songjiang");
        HeroNode heroNode2 = new HeroNode(2,"songjian");
        HeroNode heroNode3 = new HeroNode(3,"sunjiang");
        HeroNode heroNode4 = new HeroNode(4,"songji");
        HeroNode heroNode5 = new HeroNode(5,"guansheng");


        heroNode1.setLeft(heroNode2);
        heroNode1.setRight(heroNode3);
        heroNode3.setRight(heroNode4);
        heroNode3.setLeft(heroNode5);
        binaryTree.setRoot(heroNode1);
        binaryTree.preOrder1();
        System.out.println("==========");
        binaryTree.midOrder1();
        System.out.println("==========");
        HeroNode resNode = binaryTree.preOrderSearch1(7);
        System.out.println(resNode);
    }
}
//定义二叉树
class  BinaryTree{
    private HeroNode root;//根节点
    public void setRoot(HeroNode root){
        this.root = root;
    }
    //前序遍历
    public void preOrder1(){
        if(this.root != null){
            this.root.preOrder();
        }else{
            System.out.println("当前二叉树为空");
        }
    }
    //中序遍历
    public void midOrder1(){
        if(this.root != null){
            this.root.midOrder();
        }else{
            System.out.println("当前二叉树为空");
        }
    }
    //后序遍历
    public void postOrder1(){
        if(this.root != null){
            this.root.postOrder();
        }else{
            System.out.println("当前二叉树为空");
        }
    }

   
   
}
class HeroNode{
    private  int no;
    private  String name;
    private  HeroNode left;//默认null
    private   HeroNode right;//默认null

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", 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 midOrder(){
        if(this.left != null){
            this.left.midOrder();
        }
        System.out.println(this);
        if(this.right != null){
            this.right.midOrder();
        }
    }
    //后序遍历
    public void postOrder(){
        if(this.left != null){
            this.left.midOrder();
        }

        if(this.right != null){
            this.right.midOrder();
        }
        System.out.println(this);
    }
   
    
    }
}

二、二叉树查找

二叉树查找的思路分析：
            1.前序查找：1.1先判断当前节点的no是否等于要查找的no；
                                 1.2若相等，则返回当前节点；
                                 1.3如果不等，则判断当前节点的左子节点是否为空，
                                     如果不为空，则继续前序查找。如果找到则返回。
                                 1.4否则判断右子节点是否为空，如果不为空，则进行
                                     右递归的前序查找。
            2.中序查找：2.1先判断左子节点不为空,向左查找，如果找到则返回
                                 2.2如果没找到则判断当前节点的no，如果相等则返回
                                 2.3否则判断右子节点是否为空，不为空进行中序查找
            3.后序查找：3.1先判断当左子节点是否为空,进行查找，找到则返回
                                 3.2否则判断右子节点不为空，则向右继续后序查找，
                                 3.3若没找到则与当前节点进行比较。否则返回null。

二叉树前序查找的相关代码实现

package com.shangguigu.javase.binarytree;

public class BinaryTreeTest {
    public static void main(String[] args) {
        //创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        HeroNode heroNode1 = new HeroNode(1,"songjiang");
        HeroNode heroNode2 = new HeroNode(2,"songjian");
        HeroNode heroNode3 = new HeroNode(3,"sunjiang");
        HeroNode heroNode4 = new HeroNode(4,"songji");
        HeroNode heroNode5 = new HeroNode(5,"guansheng");


        heroNode1.setLeft(heroNode2);
        heroNode1.setRight(heroNode3);
        heroNode3.setRight(heroNode4);
        heroNode3.setLeft(heroNode5);
        binaryTree.setRoot(heroNode1);
        binaryTree.preOrder1();
        System.out.println("==========");
        binaryTree.midOrder1();
        System.out.println("==========");
        HeroNode resNode = binaryTree.preOrderSearch1(7);
        System.out.println(resNode);
    }
}
//定义二叉树
class  BinaryTree{
    private HeroNode root;//根节点
    public void setRoot(HeroNode root){
        this.root = root;
    }
 

    //前序查找
    public HeroNode preOrderSearch1(int no){
        if(root != null){
            return root.perOrderSearch(no);
        }else{
            return null;
        }
    }
  
}
class HeroNode{
    private  int no;
    private  String name;
    private  HeroNode left;//默认null
    private   HeroNode right;//默认null

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
    
    //前序查找
    public HeroNode perOrderSearch(int no){
        //先比较当前节点与要查找的no
        if(this.no == no){
            return this;
        }
        //则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
        HeroNode resNode = null;
        if(this.left != null){
           resNode = this.left.perOrderSearch(no);
        }
        if(resNode != null){
            return resNode;
        }
        if(this.right != null){
            resNode = this.right.perOrderSearch(no);
        }

        return  resNode;
    }
    
    
}

三、二叉树删除

规定：如果删除的是叶子节点则直接删除节点
           如果删除的是非叶子节点，则删除该子树

基本思路：
1.因为二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除，
   而不能判断当前节点是不是要删除的节点
2.如果当前节点的左子树不为空并且左子节点就是要删除的节点，我们将
   this.left = null;并且结束删除任务;
3.如果当前节点的右子树不为空并且右子节点就是要删除的节点，我们将
   this.right = null;并且结束删除任务;
4.如果第二和第三步没有删除成功，则需要向左子树进行递归删除
5.若第四步没有删除成功，则需要向右子树进行递归删除
6.如果树是空树，如果只有一个root节点，则将二叉树置空。

二叉树删除节点的代码实现

package com.shangguigu.javase.binarytree;

public class BinaryTreeTest {
    public static void main(String[] args) {
        //创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        HeroNode heroNode1 = new HeroNode(1,"songjiang");
        HeroNode heroNode2 = new HeroNode(2,"songjian");
        HeroNode heroNode3 = new HeroNode(3,"sunjiang");
        HeroNode heroNode4 = new HeroNode(4,"songji");
        HeroNode heroNode5 = new HeroNode(5,"guansheng");


        heroNode1.setLeft(heroNode2);
        heroNode1.setRight(heroNode3);
        heroNode3.setRight(heroNode4);
        heroNode3.setLeft(heroNode5);
        binaryTree.setRoot(heroNode1);
        binaryTree.preOrder1();
        System.out.println("==========");
        binaryTree.midOrder1();
        System.out.println("==========");
        HeroNode resNode = binaryTree.preOrderSearch1(7);
        System.out.println(resNode);
    }
}
//定义二叉树
class  BinaryTree{
    private HeroNode root;//根节点
    public void setRoot(HeroNode root){
        this.root = root;
    }
   
    //删除节点
    public void delNode1(int no){
        if(root != null){
            if(root.getNo() == no){
                root = null;
            }else{
                root.delNode(no);
            }
        }else{
            System.out.println("空树，不能进行删除操作");
        }
    }
}
class HeroNode{
    private  int no;
    private  String name;
    private  HeroNode left;//默认null
    private   HeroNode right;//默认null

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
    
    //递归删除节点
    public void delNode(int no){
        if(this.left != null && this.left.no == no){
            this.left = null;
            return;
        }
        if(this.right != null && this.right.no == no){
            this.right = null;
            return;
        }
        if(this.left != null){
            this.left.delNode(no);
        }
        if(this.right != null){
            this.right.delNode(no);
        }
    }
}

四、二叉树的顺序存储

特点：
    顺序二叉树通常只考虑完全二叉树
    第n个元素的左子节点为2n+1
    第n个元素的右子节点为2n+2
    第n个元素的父节点为（n-1）/2

二叉树顺序存储的代码实现

package com.shangguigu.javase.binarytree;

public class BinaryTreeTest01 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};
        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(arr);
        arrayBinaryTree.preOrder(0);
        System.out.println("========");
        arrayBinaryTree.midOrder(0);
    }
}
//编写一个ArrayBinaryTree，实现顺序存储二叉树遍历
class ArrayBinaryTree{
    private int[] arr;

    public ArrayBinaryTree(int[] arr) {
        this.arr = arr;
    }
    //编写一个方法，完成顺序二叉树的前序遍历
    public void preOrder(int index){
        //如果数组为空
        if(arr.length == 0 || arr == null){
            System.out.println("不能进行前序遍历");
        }
        System.out.println(arr[index]);
        //向左遍历递归
        if((2*index + 1) < arr.length) {
            preOrder(2 * index + 1);
        }
        //向右递归
        if((2*index + 2 )< arr.length){
            preOrder(2*index + 2);
        }
    }
    //编写一个方法，完成顺序二叉树的中序遍历
    public void midOrder(int index){
        //如果数组为空
        if(arr.length == 0 || arr == null){
            System.out.println("不能进行前序遍历");
        }
        //向左遍历递归
        if((2*index + 1) < arr.length) {
           midOrder(2 * index + 1);
        }
        System.out.println(arr[index]);
        //向右递归
        if((2*index + 2 )< arr.length){
            midOrder(2*index + 2);
        }
    }
}