二叉树前中后序遍历、查找和删除

首先，我们定义树结点

class TreeNode{
    private int no;
    private String name;
    private TreeNode left;
    private TreeNode right;

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

    @Override
    public String toString() {
        return "TreeNode{" +
                "no=" + no +
                ", 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 TreeNode getLeft() {
        return left;
    }

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

    public TreeNode getRight() {
        return right;
    }

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

    public void prefixOrder(){
        System.out.println(this);
        if (this.left!=null){
            this.left.prefixOrder();
        }
        if (this.right!=null){
            this.right.prefixOrder();
        }
    }

    public void infixOrder(){
        if (this.left!=null){
            this.left.infixOrder();
        }
        System.out.println(this);
        if (this.right!=null){
            this.right.infixOrder();
        }
    }

    public void suffixOrder(){
        if (this.left!=null){
            this.left.suffixOrder();
        }
        if (this.right!=null){
            this.right.suffixOrder();
        }
        System.out.println(this);
    }
}

其次，定义二叉树 

class BinaryTree{
    private TreeNode root;

    public void setRoot(TreeNode root) {
        this.root = root;
    }

    public void prefixOrder(){
        if (this.root!=null){
            this.root.prefixOrder();
        }else {
            System.out.println("二叉树为空，无法遍历！");
        }
    }

    public void infixOrder(){
        if (this.root!=null){
            this.root.infixOrder();
        }else {
            System.out.println("二叉树为空，无法遍历！");
        }
    }

    public void suffixOrder(){
        if (this.root!=null){
            this.root.suffixOrder();
        }else {
            System.out.println("二叉树为空，无法遍历！");
        }
    }
}

接着，我们在主方法中测试上面书写的遍历是否正确

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        TreeNode root = new TreeNode(1, "张三");
        TreeNode node2 = new TreeNode(2, "李四");
        TreeNode node3 = new TreeNode(3, "王五");
        TreeNode node4 = new TreeNode(4, "赵六");
        TreeNode node5 = new TreeNode(5, "田七");
        root.setLeft(node2);
        root.setRight(node3);
        node3.setLeft(node5);
        node3.setRight(node4);
        binaryTree.setRoot(root);
        System.out.println("前序遍历：");
        binaryTree.prefixOrder();
        System.out.println("中序遍历");
        binaryTree.infixOrder();
        System.out.println("后序遍历");
        binaryTree.suffixOrder();
    }
}

预想的前序遍历结果：张三->李四->王五->田七->赵六

预想的中序遍历结果：李四->张三->田七->王五->赵六  

预想的后序遍历结果：李四->田七->赵六->王五->张三

前中后序查找元素

在树节点类TreeNode上添加前中后排序遍历查找方法

public TreeNode prefixOrderSearch(int no) {
        System.out.println("进入前序遍历查找~~");
        if (this.no == no) {
            return this;
        }
        TreeNode resNode = null;
        if (this.left != null) {
            resNode = this.left.prefixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.prefixOrderSearch(no);
        }
        return resNode;
    }

    public TreeNode infixOrderSearch(int no) {
        TreeNode resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("进入中序遍历查找~~");
        if (this.no == no) {
            return this;
        }
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    public TreeNode suffixOrderSearch(int no) {
        TreeNode resNode = null;
        if (this.left != null) {
            resNode = this.left.suffixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.suffixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("进入后序遍历查找~~");
        if (this.no == no) {
            return this;
        }
        return resNode;
    }

在二叉树类BinaryTree上也添加前中后序遍历查找方法 

public TreeNode prefixOrderSearch(int no){
        if (root!=null){
            return root.prefixOrderSearch(no);
        }else {
            return null;
        }
    }

    public TreeNode infixOrderSearch(int no){
        if (root!=null){
            return root.infixOrderSearch(no);
        }else {
            return null;
        }
    }

    public TreeNode suffixOrderSearch(int no){
        if (root!=null){
            return root.suffixOrderSearch(no);
        }else {
            return null;
        }
    }

最后，我们对以上前中后序遍历查找进行测试，eg查找5元素（存在）

//        System.out.println("前序遍历查找~~");
//        TreeNode resNode = binaryTree.prefixOrderSearch(5);

//        System.out.println("中序遍历查找~~");
//        TreeNode resNode = binaryTree.infixOrderSearch(5);
    
        System.out.println("后序遍历查找~~");
        TreeNode resNode = binaryTree.suffixOrderSearch(5);
        if (resNode!=null){
            System.out.printf("找到了，信息为no=%d name=%s",resNode.getNo(),resNode.getName());
        }else {
            System.out.printf("没有找到no=%d 的人物",5);
        }

总结：后序遍历查找2次，中序遍历查找3次，前序遍历查找4次

删除节点

在树节点类TreeNode上添加删除节点方法

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);
        }
    }

 在二叉树类BinaryTree上也添加删除节点方法 

public void delNode(int no) {
        if (root != null) {
            if (root.getNo() == no) {
                root = null;
            } else {
                root.delNode(no);
            }
        } else {
            System.out.println("该树为空树，无法删除！");
        }
    }

在main方法上测试，运行结果如下：

System.out.println("删除前，前序遍历");
        binaryTree.prefixOrder();
        binaryTree.delNode(3);
        System.out.println("删除后，前序遍历");
        binaryTree.prefixOrder();

顺序存储二叉树特点

 定义数组二叉树类

class ArrBinaryTree {
    private int[] arr;

    public ArrBinaryTree(int arr[]) {
        this.arr = arr;
    }

    public void preOrder(){
        this.preOrder(0);
    }

    public void midOrder(){
        this.midOrder(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) {
            preOrder(2 * index + 1);
        }
        //向右递归遍历
        if ((2 * index + 2) < arr.length) {
            preOrder((2 * index + 2));
        }
    }

    /**
     * 编写一个方法，完成顺序存储二叉树的中序遍历
     *
     * @param index 数组的下标
     */
    public void midOrder(int index) {
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        //向左递归遍历
        if ((2 * index + 1) < arr.length) {
            midOrder(2 * index + 1);
        }
        //输出当前这个元素
        System.out.print(arr[index]+" ");
        //向右递归遍历
        if ((2 * index + 2) < arr.length) {
            midOrder((2 * index + 2));
        }
    }

    /**
     * 编写一个方法，完成顺序存储二叉树的后序遍历
     *
     * @param index 数组的下标
     */
    public void postOrder(int index) {
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        //向左递归遍历
        if ((2 * index + 1) < arr.length) {
            postOrder(2 * index + 1);
        }
        //向右递归遍历
        if ((2 * index + 2) < arr.length) {
            postOrder((2 * index + 2));
        }
        //输出当前这个元素
        System.out.print(arr[index]+" ");
    }
}

主方法测试类

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        ArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);
        arrBinaryTree.preOrder();// 1 2 4 5 3 6 7
        System.out.println();
        arrBinaryTree.midOrder();
        System.out.println();
        arrBinaryTree.postOrder();
    }

 

总结：顺序存储二叉树的实际应用是堆排序