数据结构(4)树形结构——二叉树（概述、前序、中序、后序、层序遍历JAVA实现）

目录

4.1.树

4.2.二叉树

4.2.1.概述

4.2.3.存储结构

4.2.3.遍历

1.逻辑简介

 2.代码示例

---

4.1.树

树，由n(n≥0)个有限节点和边组成一个具有层次关系的数据结构。树需要满足以下条件：

• 任何结点的子节点不相交。
• 任何子结点只有一个父节点。
• N个结点，N-1条边。

对于一个非空树（结点数≥0），具有以下性质：

• 起始结点称为“根”
• 除根结点外可分为m个互不相交的有限集合，其中每个集合本身也是一棵树，称为原来这棵树的“子树”。

 树的基本术语：

• 结点的度：节点的子树个数
• 树的度：树的所有结点中最大的度数
• 叶结点：度为0的结点
• 父结点：有子树的结点都是它的子树的根结点
• 子结点：若A是B的父结点，则B是A的子节点
• 兄弟结点：具有同一父结点的结点彼此是

4.2.二叉树

4.2.1.概述

二叉树是一种每个结点的度不大于2的树，由根结点和左子树、右子树组成，具有以下五种姿态：

 除了五种基本姿态外，还有三种比较特殊的姿态：

4.2.3.存储结构

二叉树可以用两种结构存储，一种是链表，一种是数组。

数组表示的话第一个位置存储的根结点，挨着根结点的是根结点的左右孩子，接下来是根结点左孩子的左右孩子，右孩子的左右孩子，以此类推：

 数组仅适合完全二叉树（完美二叉树是特殊的完全二叉树），以为当表示非完全而二叉树，会出现大面积内存空间浪费的情况：

4.2.3.遍历

1.逻辑简介

二叉的遍历，本质上是二维结构的线性化，二叉树本来是非线性的，但是其结果最后是线性的。

二叉树的遍历根据访问当前子树的根结点的顺序分为四种：

• 先序遍历
• 中序遍历
• 后序遍历

除此之外还有一种特殊的遍历，层序遍历，按照每一层来遍历。

层序遍历需要用到一个队列来实现：

首先是根结点入队，然后访问根结点，根结点左右孩子顺序入队，根结点出队，然后队列中的后续结点重复上述的出队入队流程，直到队列为空，整个层序遍历过程就结束。

 2.代码示例

二树的结点：

public class Node {
    //数据域
    private int data;
    //指针域
    private Node left;
    private Node right;

    //遍历标志
    private boolean isOrder;

    {
        isOrder=false;
    }

    public Node(){

    }

    public Node(int data){
        this.data=data;
    }
    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    public boolean isOrder() {
        return isOrder;
    }

    public void setOrder(boolean order) {
        isOrder = order;
    }
}

 各种遍历的实现：

public class BinaryTree {

    //判断BT是否为空
    public static boolean isEmpty(Node root){
        //判断操作
        return  root==null?true:false;
    }


    //先序建树
    public static Node create(Node node,Scanner scanner){
        Integer data=Integer.parseInt(scanner.next());
        if(data!=-1){
            node=new Node();
            node.setData(data);
            node.setLeft(create(node,scanner));
            node.setRight(create(node,scanner));
        }
        //以防万一，如果节点为叶节点时，将其左右指针置空
        if(data==-1){
            node.setLeft(null);
            node.setRight(null);
        }
        return node;
    }

    //递归先序遍历二叉树
    public static void pre(Node node){
        //需要给节点增加一个遍历状态标志位
        //每次递归回溯时需要判断当前节点的标志位是否为已遍历状态
        //否则会徘徊在叶节点，堆栈溢出
        if(node!=null&!node.isOrder()){
            System.out.println(node.getData());
            node.setOrder(true);
            pre(node.getLeft());
            pre(node.getRight());
        }
    }

    //中序遍历
    public static  void mid(Node node){
        if(node!=null&!node.isOrder()){
            node.setOrder(true);
            mid(node.getLeft());
            System.out.println(node.getData());
            mid(node.getRight());
        }
    }

    //后续遍历
    public static void post(Node node){
        if(node!=null&!node.isOrder()){
            node.setOrder(true);
            mid(node.getLeft());
            mid(node.getRight());
            System.out.println(node.getData());
        }
    }

    //层序遍历
    public static void level(){
        //递归法
        if (!queue.isEmpty()) {
            //取出队首元素
            Node node = queue.exit();
            //打印节点数据
            System.out.println(node.getData());
            //左孩子入队
            queue.Enter(node.getLeft());
            //右孩子入队
            queue.Enter(node.getRight());

            level();
        }

        //循环法
        /*while (!queue.isEmpty()) {
            //取出队首元素
            Node node = queue.exit();
            //打印节点数据
            System.out.println(node.getData());
            //左孩子入队
            queue.Enter(node.getLeft());
            //右孩子入队
            queue.Enter(node.getRight());
        }*/
    }
}

需要注意的是，层序遍历的话要用到一个队列来实现，这个队列的话用的就是之前在线性结构里实现的那个队列：

public class queue {
    private static Node[] que;
    //头指针
    private static int first;
    //尾指针
    private static int last;
    //初始化
    static{
        que=new Node[100];
        first=0;
        last=-1;
    }

    //入队
    public static void Enter(Node node){
        que[++last]=node;
    }
    //出队
    public static Node exit(){
        Node node=que[first++];
        return node;
    }
    //判空
    public static boolean isEmpty(){
        return (que[first]==null&&first==last) ? true:false;
    }
}