几种数据结构的分析、树、二叉树前序、中序、后序遍历（Java实现）

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

1. 数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度

缺点：如果要检索具体某个值，或者插入值**(按一定顺序)**会整体移动，效率较低

2. 链式存储方式的分析

优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好）

缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历）

3. 树存储方式的分析

能提高数据存储，读取的效率,比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度

二、树

示意图：

三、二叉树

1. 基本概念

• 每个节点最多只能有两个子节点的一种形式称为二叉树，注意每个节点可以没有子节点，也可以只有一个节点

• 二叉树的子节点分为左节点和右节点
  

• 满二叉树：如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树
  

• 完全二叉树：如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树
  

2. 二叉树遍历的分类

前序遍历: 先输出父节点，再遍历左子树和右子树

中序遍历: 先遍历左子树，再输出父节点，再遍历右子树

后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点

即：看输出父节点的顺序，就确定是前序，中序还是后序

例如：上图所示的二叉树

前序遍历得到的结果是：张三、李四、王五、赵六、田七

中序遍历得到的结果是：李四、张三、赵六、王五、田七

后序遍历得到的结果是：李四、赵六、田七、王五、张三

四、二叉树的前序、中序和后序遍历

要实现上图所示二叉树，首先需要创建二叉树的节点 ，再创建二叉树，而要实现遍历，则需要使用递归

前序遍历思路：

1. 输出父节点
2. 递归向左子树前序遍历
3. 递归向右子树前序遍历

中序遍历思路：

1. 递归向左子树中序遍历
2. 输出父节点
3. 递归向右子树中序遍历

后序遍历思路：

1. 递归向左子树后序遍历
2. 递归向右子树后序遍历
3. 输出父节点

代码实现：

节点代码：

//节点
class PersonNode {
    private int num;
    private String name;
    private PersonNode left;
    private PersonNode right;

    public PersonNode() {
    }

    public PersonNode(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public PersonNode getLeft() {
        return left;
    }

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

    public PersonNode getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "PersonNode{" +
                "num=" + num +
                ", 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 midOrder() {
        //先递归向左子树遍历
        if (this.left != null) {
            this.left.midOrder();
        }
        //输出父节点
        System.out.println(this);
        //递归向右子树遍历
        if (this.right != null) {
            this.right.midOrder();
        }
    }

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

二叉树：

class BinaryTree {
    private PersonNode root;

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

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

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

    //后序遍历
    public void postOrder() {
        if (root != null) {
            root.postOrder();
        } else {
            System.out.println("二叉树为空，不能遍历");
        }
    }
}

测试：

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();

        PersonNode root = new PersonNode(1, "张三");
        PersonNode node2 = new PersonNode(2, "李四");
        PersonNode node3 = new PersonNode(3, "王五");
        PersonNode node4 = new PersonNode(4, "赵六");
        PersonNode node5 = new PersonNode(5, "田七");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setLeft(node4);
        node3.setRight(node5);
        binaryTree.setRoot(root);

        System.out.println("前序遍历：");
        binaryTree.preOrder();
        System.out.println("--------------------------------");
        System.out.println("中序遍历：");
        binaryTree.midOrder();
        System.out.println("--------------------------------");
        System.out.println("后序遍历");
        binaryTree.postOrder();

    }
}

测试结果：