数据结构 - 二叉树(前序中序后序查找)

小咪咪 2023-07-03 04:51 1阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70]

public static int i = 1, j = 1, k =1;
        //编写前序查找方法
        public HeroNode preOrderSearch(int no){ 
            System.out.println("前序遍历"+(i++)+"次");
            if (this.no == no){ 
                return this;
            }
            HeroNode heroNode = null;
            if (this.left != null){ 
                heroNode = this.left.preOrderSearch(no);
            }
            //不等于空说明在左边找到了
            if (heroNode != null){ 
                return heroNode;
            }
            if (this.right != null){ 
                heroNode = this.right.preOrderSearch(no);
            }
            return heroNode;
        }
    
        //中序遍历查找
        public HeroNode infixOrderSearch(int no){ 
    
            HeroNode heroNode = null;
            //先判断当前节点的左子节点是否为空，不为空继续进行中序查找
            if (this.left != null){ 
                heroNode = this.left.infixOrderSearch(no);
            }
            if (heroNode != null){ 
                return heroNode;
            }
            System.out.println("中序遍历"+(j++)+"次");
            if (this.no == no){ 
                return this;
            }
            if (this.right != null){ 
                heroNode = this.right.infixOrderSearch(no);
            }
    
            return heroNode;
        }
    
        //后序遍历查找
        public HeroNode postOrderSearch(int no){ 
    
            HeroNode heroNode = null;
            //判断当前节点的左子节点是否为空，不为空，则递归后序遍历查找
            if (this.left != null){ 
                heroNode = this.left.postOrderSearch(no);
            }
            if (heroNode != null){ 
                return heroNode;
            }
            //判断当前节点的右子节点是否为空，不为空，则递归后序遍历查找
            if (this.right != null){ 
                heroNode = this.right.postOrderSearch(no);
            }
            if (heroNode != null){ 
                return heroNode;
            }
            System.out.println("后序遍历"+(k++)+"次");
            //左右子树都没有找到，比较当前节点是不是
            if (this.no == no){ 
                return this;
            }
            return heroNode;
        }

//前序查找
        public HeroNode preOrederSearch(int no){ 
            if (root != null){ 
                return root.preOrderSearch(no);
            }else { 
                return null;
            }
        }
        //中序查找
        public HeroNode infixOrderSeach(int no){ 
            if (root != null){ 
                return root.infixOrderSearch(no);
            }else { 
                return null;
            }
        }
        //后序查找
        public HeroNode postOrderSeach(int no){ 
            if (root != null){ 
                return root.postOrderSearch(no);
            }else { 
                return null;
            }
        }

# 完整代码 #

package tree;
    
    public class BinaryTreeDemo { 
        public static void main(String[] args) { 
            //先需要创建一颗二叉树
            BinaryTree binaryTree = new BinaryTree();
    
            //创建需要的节点
            HeroNode root = new HeroNode(1, "宋江");
            HeroNode node2 = new HeroNode(2, "吴用");
            HeroNode node3 = new HeroNode(3, "卢俊义");
            HeroNode node4 = new HeroNode(4, "林冲");
            HeroNode node5 = new HeroNode(5, "关胜");
    
            //说明，先手动创建该二叉树，后面学习递归方式创建二叉树
            binaryTree.setRoot(root);
            root.setLeft(node2);
            root.setRight(node3);
            node3.setRight(node4);
            node3.setLeft(node5);
    
            //测试
    // System.out.println("前序遍历");
    // binaryTree.preOrder();
    // System.out.println("中序遍历");
    // binaryTree.infixOrder();
    // System.out.println("后序遍历");
    // binaryTree.postOrder();
    
            //测试查找
            //前序遍历查找
            System.out.println("前序遍历查找：~~~~");
            HeroNode heroNode1 = binaryTree.preOrederSearch(5);
            if (heroNode1 != null){ 
                System.out.println("找到节点：" + heroNode1.toString());
            }else { 
                System.out.println("没有找到");
            }
    
    // //中序遍历查找
            System.out.println("中序遍历查找：~~~~");
            HeroNode heroNode2 = binaryTree.infixOrderSeach(5);
            if (heroNode2 != null){ 
                System.out.println("找到节点：" + heroNode2.toString());
            }else { 
                System.out.println("没有找到");
            }
    
            //后序遍历查找
            System.out.println("后序遍历查找：~~~~");
            HeroNode heroNode3 = binaryTree.postOrderSeach(5);
            if (heroNode3 != null){ 
                System.out.println("找到节点：" + heroNode3.toString());
            }else { 
                System.out.println("没有找到");
            }
    
        }
    }
    
    class BinaryTree{ 
        private HeroNode root;
        public void setRoot(HeroNode 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("二叉树为空无法遍历");
            }
        }
    
        //前序查找
        public HeroNode preOrederSearch(int no){ 
            if (root != null){ 
                return root.preOrderSearch(no);
            }else { 
                return null;
            }
        }
        //中序查找
        public HeroNode infixOrderSeach(int no){ 
            if (root != null){ 
                return root.infixOrderSearch(no);
            }else { 
                return null;
            }
        }
        //后序查找
        public HeroNode postOrderSeach(int no){ 
            if (root != null){ 
                return root.postOrderSearch(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 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 static int i = 1, j = 1, k =1;
        //编写前序查找方法
        public HeroNode preOrderSearch(int no){ 
            System.out.println("前序遍历"+(i++)+"次");
            if (this.no == no){ 
                return this;
            }
            HeroNode heroNode = null;
            if (this.left != null){ 
                heroNode = this.left.preOrderSearch(no);
            }
            //不等于空说明在左边找到了
            if (heroNode != null){ 
                return heroNode;
            }
            if (this.right != null){ 
                heroNode = this.right.preOrderSearch(no);
            }
            return heroNode;
        }
    
        //中序遍历查找
        public HeroNode infixOrderSearch(int no){ 
    
            HeroNode heroNode = null;
            //先判断当前节点的左子节点是否为空，不为空继续进行中序查找
            if (this.left != null){ 
                heroNode = this.left.infixOrderSearch(no);
            }
            if (heroNode != null){ 
                return heroNode;
            }
            System.out.println("中序遍历"+(j++)+"次");
            if (this.no == no){ 
                return this;
            }
            if (this.right != null){ 
                heroNode = this.right.infixOrderSearch(no);
            }
    
            return heroNode;
        }
    
        //后序遍历查找
        public HeroNode postOrderSearch(int no){ 
    
            HeroNode heroNode = null;
            //判断当前节点的左子节点是否为空，不为空，则递归后序遍历查找
            if (this.left != null){ 
                heroNode = this.left.postOrderSearch(no);
            }
            if (heroNode != null){ 
                return heroNode;
            }
            //判断当前节点的右子节点是否为空，不为空，则递归后序遍历查找
            if (this.right != null){ 
                heroNode = this.right.postOrderSearch(no);
            }
            if (heroNode != null){ 
                return heroNode;
            }
            System.out.println("后序遍历"+(k++)+"次");
            //左右子树都没有找到，比较当前节点是不是
            if (this.no == no){ 
                return this;
            }
            return heroNode;
        }
    }

## 后序遍历查找最快 ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200202141243299.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNjA4NA==,size_16,color_FFFFFF,t_70