二叉树Java数据结构篇_java二叉树有哪些结构

本章学习目录

• 页内目录
  一，二叉树的介绍
  二，二叉树的图解
  三，二叉树的名词解释
  四，二叉树的节点
  五，二叉树的三序遍历
  六，二叉树的节点删除
  七，二叉树的测试

一，二叉树的介绍

• 二叉树：（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分 。

二，二叉树的图解

三，二叉树的名词解释（摘自百度）

• 节点：1，2，3，4，5，6，7都是节点
• 根节点：1是根节点，根节点记为root
• 父节点：1是2和3的父节点，2是4和5的父节点
• 子节点：2是1的左子节点，3是1的右子节点
• 叶子节点：没有子节点的节点，如：4，5，6，7
• 节点的权：节点的值
• 路径：从根节点到该节点的路线
• 层：1是第一层，2和3是第二层，依次类推
• 子树：以2为根的树，是以1为根的树的子树
• 树的高度：最大层数
• 森林：互不相交的树构成一片森林。如果把一棵非空的树的根结点删除，则该树就变成了一片森林，森林中的树由原来根结点的各棵子树构成

四，二叉树的节点

public class Node {
    int no;
    String data;
    Node left;//左节点
    Node right;//右节点

    //提供一个构造方法，创建节点
    public Node(int no, String data) {
        this.no = no;
        this.data = data;
    }
   
    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", data='" + data + '\'' +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

五，二叉树的三序遍历

• 前序遍历：先读根节点，再读左子节点，再读右子节点；例：1245367
• 中序遍历：有左子节点先读左子节点，再读左子节点的根节点，再读右子节点；例：4251637
• 后续遍历：有左子节点先读左子节点，再读右子节点，再读左右子节点的根节点；例：4526731
• 注：前，中，后都是对根节点而言的

    //前序遍历，传入根节点
    public void preOrder(Node node) {
        //如果传入根节点为null则该二叉树不存在
        if (node == null) {
            System.out.println("二叉树不存在");
            return;
        }
        //先打印父节点
        System.out.println(node);
        //再打印左子树，递归
        if (node.left != null) {
            preOrder(node.left);
        }
        //再打印右子树，递归
        if (node.right != null) {
            preOrder(node.right);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

    //中序遍历，传入根节点
    public void infixOrder(Node node) {
        //如果传入根节点为null则该二叉树不存在
        if (node == null) {
            System.out.println("二叉树不存在");
            return;
        }
        //先打印左子树，递归
        if (node.left != null) {
            infixOrder(node.left);
        }
        //再打印父节点
        System.out.println(node);
        //再打印右子树，递归
        if (node.right != null) {
            infixOrder(node.right);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

    //后序遍历，传入根节点
    public void postOrder(Node node) {
        //如果传入根节点为null则该二叉树不存在
        if (node == null) {
            System.out.println("二叉树不存在");
            return;
        }
        //先打印左子树，递归
        if (node.left != null) {
            postOrder(node.left);
        }
        //再打印右子树，递归
        if (node.right != null) {
            postOrder(node.right);
        }
        //再打印父节点
        System.out.println(node);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

六，二叉树的节点删除，（叶子节点直接删除，非叶子节点连同子树一起删除，（不支持删除根节点））

    public void deleteNode(Node root, int no) {
        //空树情况
        if (root == null) {
            System.out.println("空树");
            return;
        }
        //删除的是根节点
        if (root.no == no) {
            System.out.println("删除失败！根节点不能删除");
            return;
        }
        //判断左孩子
        if (root.left != null && root.left.no == no) {
            root.left = null;
            return;
        }
        //判断右孩子
        if (root.right != null && root.right.no == no) {
            root.right = null;
            return;
        }
        //递归向左
        if (root.left != null) {
            deleteNode(root.left, no);
        }
        //递归向右
        if (root.right != null) {
            deleteNode(root.right, no);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

七，二叉树的测试

        Node node1 = new Node(1, "李白");
        Node node2 = new Node(2, "苏轼");
        Node node3 = new Node(3, "杜甫");
        Node node4 = new Node(4, "白居易");
        Node node5 = new Node(5, "呀呼");
        Node node6 = new Node(6, "火花");
        Node node7 = new Node(7, "giao");
        //简单的构建一个二叉树
        node1.left = node2;
        node2.left = node4;
        node2.right = node5;
        node1.right = node3;
        node3.left = node6;
        node3.right = node7;

        BinaryTree binaryTree = new BinaryTree();
        System.out.println("前序遍历");
        binaryTree.preOrder(node1);//1245367
        System.out.println("中序遍历");
        binaryTree.infixOrder(node1);//4251637
        System.out.println("后续遍历");
        binaryTree.postOrder(node1);//4526731

        binaryTree.deleteNode(node1, 3);
        System.out.println("删除后的前序遍历");
        binaryTree.preOrder(node1);//1245

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

结果：