二叉树

最新推荐文章于 2022-05-01 12:47:37 发布

Dkui

最新推荐文章于 2022-05-01 12:47:37 发布

阅读量153

点赞数

分类专栏： Java数据结构与算法文章标签：数据结构算法 java 二叉树

本文链接：https://blog.csdn.net/qq_43618030/article/details/104355711

版权

Java数据结构与算法专栏收录该内容

18 篇文章 1 订阅

订阅专栏

为什么需要树这种数据结构

在这里插入图片描述

数组存储方式分析图解

在这里插入图片描述

以ArrayList为例，看看是怎样进行数组扩容-代码

package com.tree;

import java.util.ArrayList;
import java.util.Arrays;

public class Test {

    @SuppressWarnings("unused")
    public static void main(String[] args) {
        //以ArrayList为例，看看是怎样进行数组扩容
        @SuppressWarnings("rawtypes")
        //ArrayList 维护数组trasient Object[] elementSata;
                /**
                 * ArrayList 底层仍然进行的是数组扩容
                 */
                ArrayList arrayList = new ArrayList();
    }
}

分析如果以2二叉树来存储数据，那么对数据的增删改查的效率都可以提高

在这里插入图片描述

树示意图

树的常用术语

在这里插入图片描述

二叉树的概念

在这里插入图片描述

二叉树遍历说明

在这里插入图片描述

分析二叉树的前序，中序，后序的遍历步骤

在这里插入图片描述

二叉树遍历应用实例（前序，中序，后序）

在这里插入图片描述

代码

先创建HeroNode结点

package com.tree;

public class BinaryTreeDemo {

    public static void main(String[] args) {

    }
}

//先创建HeroNode结点
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;
    }
}

先创建HeroNode结点-get和set方法

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

先创建HeroNode结点-toString方法

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

先创建HeroNode结点-编写前序遍历的方法-先输出父节点

    //编写前序遍历的方法
    public void perOrder() {
        System.out.println(this);//先输出父节点
    }

先创建HeroNode结点-编写前序遍历的方法-先输出父节点先输出父节点

        //递归向左子树前序遍历
        if (this.left != null) {
            this.left.perOrder();
        }

先创建HeroNode结点-编写前序遍历的方法-递归向右子树前序遍历

        //递归向右子树前序遍历
        if (this.left != null) {
            this.right.perOrder();
        }

先创建HeroNode结点-中序遍历-递归向左子树中序遍历

    //中序遍历
    public void infixOrder() {
        //递归向左子树中序遍历
        if (this.left != null) {
            this.left.perOrder();
        }
    }

先创建HeroNode结点-中序遍历-输出父节点

        //输出父节点
        System.out.println(this);

先创建HeroNode结点-中序遍历-递归向右子树前序遍历

        //递归向右子树中序遍历
        if (this.right != null) {
            this.right.perOrder();
        }

先创建HeroNode结点-后序遍历-递归向左子树后序遍历

    //后序遍历
    public void postOrder() {
        //递归向左子树后序遍历
        if (this.left != null) {
            this.postOrder();
        }
    }

先创建HeroNode结点-后序遍历-递归向右子树后序遍历

        //递归向右子树后序遍历
        if (this.right != null) {
            this.right.postOrder();
        }

先创建HeroNode结点-后序遍历-输出父节点

        //输出父节点
        System.out.println(this);

定义BinaryTree 二叉树

//定义BinaryTree 二叉树
class BinaryTree {
    private HeroNode root;

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

定义BinaryTree 二叉树-前序遍历

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

定义BinaryTree 二叉树-中序遍历

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

定义BinaryTree 二叉树-后序排序

    //后序排序
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        }
    }

测试-先需要创建一个二叉树

        //测试
        //先需要创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();

测试-创建需要结点

        //创建需要结点
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "吕俊义");
        HeroNode node4 = new HeroNode(4, "林冲");

测试-首先，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树

        //首先 ，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        binaryTree.setRoot(root);

测试-前序遍历,中序遍历,后序遍历

        //测试
        System.out.println("前序遍历");//1,2,3,4
        binaryTree.perOrder();

        //测试
        System.out.println("中序遍历");//2,1,3,4
        binaryTree.infixOrder();

        //测试
        System.out.println("后序遍历");//2,4,3,1
        binaryTree.infixOrder();

测试-新增一个结点

        //创建需要结点
        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, "关胜");

        //首先 ，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);

测试-修改bug

        //测试
        System.out.println("前序遍历");//1,2,3,5,4
        binaryTree.perOrder();

        //测试
        System.out.println("中序遍历");//2,1,5,3,4
        binaryTree.infixOrder();

        //测试
        System.out.println("后序遍历");//2,5,4,3,1
        binaryTree.postOrder();
    }
}

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

    public void infixOrder() {
        //递归向左子树中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        //输出父节点
        System.out.println(this);
        //递归向右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

完整代码

package com.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, "关胜");

        //首先 ，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);

        //测试
        System.out.println("前序遍历");//1,2,3,5,4
        binaryTree.perOrder();

        //测试
        System.out.println("中序遍历");//2,1,5,3,4
        binaryTree.infixOrder();

        //测试
        System.out.println("后序遍历");//2,5,4,3,1
        binaryTree.postOrder();
    }
}

//定义BinaryTree 二叉树
class BinaryTree {
    private HeroNode root;

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

    //前序遍历
    public void perOrder() {
        if (this.root != null) {
            this.root.perOrder();
        } 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();
        }
    }
}

//先创建HeroNode结点
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 perOrder() {
        System.out.println(this);//先输出父节点
        //递归向左子树前序遍历
        if (this.left != null) {
            this.left.perOrder();
        }
        //递归向右子树前序遍历
        if (this.right != null) {
            this.right.perOrder();
        }
    }

    //中序遍历
    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);
    }
}

Dkui

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二叉树

为什么需要树这种数据结构数组存储方式分析图解以ArrayList为例，看看是怎样进行数组扩容-代码package com.tree;import java.util.ArrayList;import java.util.Arrays;public class Test { @SuppressWarnings("unused") public static vo...
复制链接

扫一扫