二叉树的概念

二叉树

任何一个节点的子节点的数量不超过2。二叉树的子节点分为左节点和右节点。
满二叉树：所有子节点的都在最后一层，而且节点的总数为$2^n-1$，n是树的高度。

完全二叉树：所有叶子节点都在最后一层或倒数第二层，且最后一层的叶子节点在左边连续，倒数第二节的叶子节点在右边连续。

二叉树的存储结构

链式存储：

代码

首先，创建树节点，每个树节点包含三个成员变量：1.数值 2.左节点的引用 3.右节点的引用

TreeNode类（节点类）

package com.wuxudong.BinaryTree;

//树的节点
public class TreeNode {

    private int data;

    public TreeNode(int data){
        this.data=data;
    }

    //左右节点
    private TreeNode leftNode;

    private TreeNode righNode;

    public void setData(int data) {
        this.data = data;
    }

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public void setRighNode(TreeNode righNode) {
        this.righNode = righNode;
    }

    public int getData() {
        return data;
    }

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public TreeNode getRighNode() {
        return righNode;
    }
}

然后，创建二叉树的类，包含一个成员变量，就是一个根节点对象

BinaryTree类(二叉树类)

package com.wuxudong.BinaryTree;

public class BinaryTree {

    //根节点
    private TreeNode rootNode;

    public TreeNode getRootNode() {
        return rootNode;
    }

    public void setRootNode(TreeNode rootNode) {
        this.rootNode = rootNode;
    }
}

最后创建一个二叉树：

MyBinaryTree类（二叉树的具体实现类）

package com.wuxudong.BinaryTree;

public class MyBinaryTree {
    public static void main(String[] args) {
        BinaryTree binaryTree=new BinaryTree();

        //创建一个节点
        TreeNode rootNode=new TreeNode(1);
        //将节点作为根节点
        binaryTree.setRootNode(rootNode);

        //创建左节点
        TreeNode lNode=new TreeNode(2);
        //创建右节点
        TreeNode rNode=new TreeNode(3);

        //设置左节点
        rootNode.setLeftNode(lNode);

        //设置右节点
        rootNode.setRighNode(rNode);

        //为第二层的左节点创建两个子节点
        lNode.setLeftNode(new TreeNode(4));
        lNode.setRighNode(new TreeNode(5));

        rNode.setLeftNode(new TreeNode(6));
        rNode.setRighNode(new TreeNode(7));
}

以上，我们创建了一个如下图所示的二叉树：

二叉树的遍历：前序遍历，中序遍历，后序遍历

主要用了递归的思想

前序遍历：根，左节点，右节点
中序遍历：左节点，根，右节点
后序遍历：左节点，右节点，根

二叉树的删除

分两种情况
1）如果删除的是根节点，则让根节点的引用指向为空。
2）如果删除的不是根节点，判断是否是根节点的左节点，如果是则删除，并将根节点的左节点作为根节点删除左子树，删完左子树后，将根节点的右节点作为根节点删除右子树。如果不是，将左节点作为根节点继续递归删除。右节点同理

代码：

MyBinaryTree类

package com.wuxudong.BinaryTree;

public class MyBinaryTree {
    public static void main(String[] args) {
        BinaryTree binaryTree=new BinaryTree();

        //创建一个节点
        TreeNode rootNode=new TreeNode(1);
        //将节点作为根节点
        binaryTree.setRootNode(rootNode);

        //创建左节点
        TreeNode lNode=new TreeNode(2);
        //创建右节点
        TreeNode rNode=new TreeNode(3);

        //设置左节点
        rootNode.setLeftNode(lNode);

        //设置右节点
        rootNode.setRighNode(rNode);

        //为第二层的左节点创建两个子节点
        lNode.setLeftNode(new TreeNode(4));
        lNode.setRighNode(new TreeNode(5));

        rNode.setLeftNode(new TreeNode(6));
        rNode.setRighNode(new TreeNode(7));

        //前序遍历
        binaryTree.frontShow();
        //中序遍历
        binaryTree.midShow();
        //后序遍历
        binaryTree.aftShow();
		//删除节点
        binaryTree.delete(4);
        binaryTree.frontShow();

    }
}

BinaryTree类

package com.wuxudong.BinaryTree;

public class BinaryTree {

    //根节点
    private TreeNode rootNode;

    public TreeNode getRootNode() {
        return rootNode;
    }

    public void setRootNode(TreeNode rootNode) {
        this.rootNode = rootNode;
    }

    //前序遍历
    public void frontShow() {
        rootNode.frontShow();
    }

    //中序遍历
    public void midShow() {
        rootNode.midShow();
    }

    //后序遍历
    public void aftShow() {
        rootNode.aftShow();
    }
	public void delete(int i) {

        if(rootNode.getData()==i){
            //如果删除的是根节点，则让根节点的指向为空
            rootNode=null;

        }else {
            //删除的不是根节点
            rootNode.delete(i);
        }
    }
}

TreeNode类

package com.wuxudong.BinaryTree;

//树的节点
public class TreeNode {

    private int data;

    public TreeNode(int data){
        this.data=data;
    }

    //左右节点
    private TreeNode leftNode;

    private TreeNode righNode;

    public void setData(int data) {
        this.data = data;
    }

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public void setRighNode(TreeNode righNode) {
        this.righNode = righNode;
    }

    public int getData() {
        return data;
    }

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public TreeNode getRighNode() {
        return righNode;
    }


    //前序遍历，先遍历当前的内容，然后左节点，右节点
    public void frontShow() {
        System.out.println(data);
        if(leftNode!=null) {
            leftNode.frontShow();
        }
        if(righNode!=null){
            righNode.frontShow();
        }

    }

    //中序遍历，先遍历左节点，然后根节点，最后右节点
    public void midShow() {
        if(leftNode!=null){
            leftNode.midShow();
        }
        System.out.println(data);
        if (righNode!=null){
            righNode.midShow();
        }

    }

    //后序遍历，先遍历左节点，然后右节点，最后根节点
    public void aftShow() {
        if(leftNode!=null){
            leftNode.aftShow();
        }
        if(righNode!=null){
            righNode.aftShow();
        }
        System.out.println(data);
    }
public void delete(int i) {
        //获取当前的根节点
        TreeNode treeNode=this;

        //删除左节点
        if(treeNode.leftNode!=null&&treeNode.leftNode.getData()==i){
            treeNode.leftNode=null;
            return;
        }



        //删除右节点
        if (treeNode.righNode!=null&&treeNode.righNode.getData()==i){
            treeNode.righNode=null;
            return;
        }

        //如果不是左节点，则递归删除左子树
        //这里的leftNode不能写成treeNode.leftNode因为里面的方法递归完之后treeNode就变了
        treeNode=leftNode;
        if (treeNode!=null) {
            treeNode.delete(i);
        }


        //如果不是右节点，递归删除右子树
        treeNode=righNode;
        if (treeNode!=null){
                treeNode.delete(i);
        }


    }
}