二叉树及其相关操作

二叉树

二叉树的概念

树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
二叉树的子节点分为左节点和右节点。

满二叉树

如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树

完全二叉树

如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。

二叉树遍历

这里的二叉树的构建，我们手动构建二叉树。

创建树节点类TreeNode.java

/**
 * @author yyq
 * @create 2021-10-27 13:17
 * 树的节点
 */
public class TreeNode <T>{
    public T data;
    public TreeNode left;
    public TreeNode right;

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

前序遍历

（1）访问根结点

（2）前序遍历左子树

（3）前序遍历右子树

在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树，如果二叉树为空则返回。

中序遍历

（1）中序遍历左子树

（2）访问根结点

（3）中序遍历右子树

后序遍历

（1）后序遍历左子树

（2）后序遍历右子树

（3）访问根节点

代码实现

public class BinaryTree {
    public static void main(String[] args) {
        TreeNode root=new TreeNode(1);
        root.left=new TreeNode(2);
        root.right=new TreeNode(3);
        root.left.left=new TreeNode(4);
        root.right.right=new TreeNode(5);
    }

    //前序遍历
    public static void preOrder(TreeNode root){
        System.out.println(root.data);
        if(root.left!=null) preOrder(root.left);
        if(root.right!=null) preOrder(root.right);
    }
    //中序遍历
    public static void inFixOrder(TreeNode root){
        if(root.left!=null) inFixOrder(root.left);
        System.out.println(root.data);
        if(root.right!=null) inFixOrder(root.right);
    }
    //后序遍历
    public static void postOrder(TreeNode root){
        if(root.left!=null) postOrder(root.left);
        if(root.right!=null) postOrder(root.right);
        System.out.println(root.data);
    }
}

查找指定节点

先序查找-后序查找-中序查找

不同点，判断的时机不一样，参考代码理解即可。

先序查找思路：

• 判断该节点的数据是否为要查找的节点，如果是返回该节点的数据
• 判断该节点的左节点是否为空，不为空，递归查找左子树，返回一个节点的数据
• 判断查找左子树的节点返回的数据是否为空，不为空，返回该数据，否则，继续像右子树递归查找

中序查找、后序类似不过多赘述。

Employee.java

package Tree;

/**
 * @author yyq
 * @create 2021-10-27 13:53
 */
public class Employee {
    private int id;
    private String  name;
		get...
    set...
    toString...
}

中序查找

如果需要记录比较次数，在判断节点前加个Count++。

 //前序查找
    public static Employee preFind(Integer id,TreeNode<Employee> root){
        count++;//记录比较次数
      //判断该节点的数据是否为需要查找的数据，如果是则返回
        if(root.data.getId()==id) {
            System.out.println(count);
            return root.data;
        }
        Employee employee = null;
      //左节点非空，递归查找左子树
        if(root.left!=null) {
           employee = preFind(id, root.left);
        }
      //看看左子树找到没有，如果找到则返回
        if(employee!=null){
            return employee;
        }
      //没找到，继续像右子树递归
        if(root.right!=null) {
           employee = preFind(id, root.right);
        }
      //返回右子树递归的查找结果
        return employee;
    }

删除节点

二叉树-删除节点
要求

• 如果删除的节点是叶子节点，则删除该节点
• 如果删除的节点是非叶子节点，则删除该子树.
• 测试，删除掉 5号叶子节点 和 3号子树.

二叉树-删除节点
思考题(课后练习)
如果要删除的节点是非叶子节点，现在我们不希望将该非叶子节点为根节点的子树删除，需要指定规则, 假如规定如下:
如果该非叶子节点A只有一个子节点B，则子节点B替代节点A
如果该非叶子节点A有左子节点B和右子节点C，则让左子节点B替代节点A。
请大家思考，如何完成该删除功能, 老师给出提示.(课后练习)
后面在讲解 二叉排序树时，在给大家讲解具体的删除方法

    //删除节点
    public static   Boolean deleteNode(TreeNode<Integer> root,TreeNode<Integer> parent,Integer fx,int id){
       //找到此节点
        Boolean flag=false;
        if(root.data==id){
            //为叶节点
            if(root.left==null&&root.right==null){
                if(fx==0) {
                    parent.left=null;
                    return true;
                }
                if(fx==1){
                    parent.right=null;
                    return true;
                }

            }
            //为非页节点
            else{
                //如果只有一个右叶子节点时
                if(root.left==null&&root.right!=null){
                    root.data= (Integer) root.right.data;
                    root.right=root.right.right;
                    return true;
                }
                //如果只有一个左叶子节点时
                if(root.left!=null&&root.right==null){
                    root.data= (Integer) root.left.data;
                    root.left=root.left.left;
                    return true;
                }
                //如果有两个节点
                if(root.left!=null&&root.right!=null){
                    TreeNode left=root.left;
                    root.data= (Integer) left.data;
                    root.left=left.left;
                    root.left.right=left.right;
                    return true;
                }
            }
        }
      	//递归查找左子树 返回结果
        if(root.left!=null) flag=deleteNode(root.left,root,0,id);
        if(flag) return flag;
      	//递归查找左子树 没找到 继续找右子树返回
        if(root.right!=null) flag=deleteNode(root.right,root,1,id);
        return flag;
    }
}

    @Test
    public void _preDelOrder(){
        TreeNode root=new TreeNode(1);
        root.left=new TreeNode(2);
        root.right=new TreeNode(3);
        root.left.left=new TreeNode(4);
        root.right.right=new TreeNode(5);
        BinaryTree.preOrder(root);
        System.out.println("****");
        Boolean flag = BinaryTree.deleteNode(root, null,null,2);
        if(flag) System.out.println("删除成功");
        else System.out.println("删除失败");
        BinaryTree.preOrder(root);
    }