数据结构与算法 13 二叉树的遍历 前序遍历 中序遍历 后序遍历

树结构

数据存储结构

1. 数组存储

   • 下标访问，速度快，有序数组可以使用二分查找等算法加快查找速度

   • 检索具体的值，或者按一定顺序插入值会整体移动，效率较低

   • 插入元素：数组需要扩容，每次在底层都需要创建新的数组，要将原来的数据拷贝到新的数据并插入新的数据

2. 链式存储

   • 插入、删除效率较高（不需要拷贝整个数组）
   • 数据查询效率较低，需要从头开始遍历

3. 树存储

   • 能够提高数据存储、读取的效率
   • 比如利用二叉排序树，既可以保证数据的检索速度，也可以保证数据的插入、删除、修改速度

---

二叉树

• 每个节点最多只能有两个子节点的一种形式称为二叉树

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

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

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

---

二叉树的遍历

• 前序遍历：先输出父节点，再遍历左子树和右子树
• 中序遍历：先输出左子树，再输出父节点，再遍历右子树
• 后序遍历：先遍历左子树，再遍历右子树，最后输出父节点

---

看父节点的位置，先遍历父节点就是先序遍历，中间遍历父节点就是中序遍历，最后遍历父节点就是后序遍历

---

前序遍历

preorder traversal

1. 先输出当前节点（根节点），判断当前节点是否为空；
2. 如果左子节点不为空，则递归继续前序遍历
3. 如果右子节点不为空，则递归继续前序遍历

---

中序遍历

infix order

1. 如果当前节点的左子节点不为空，则递归中序遍历
2. 先输出当前节点
3. 如果当前节点的右子节点不为空，则递归中序遍历

---

后序遍历

1. 如果当前节点的左子节点不为空，则递归后序遍历
2. 如果当前节点的右子节点不为空，则递归后序遍历
3. 输出当前节点

---

代码

创建树、节点、节点之间搭建关系，将根节点添加到二叉树

package tree;


public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        HeroNode root = new HeroNode(1,"joe");
        HeroNode node2 = new HeroNode(2,"jack");
        HeroNode node3 = new HeroNode(3,"jenny");
        HeroNode node4 = new HeroNode(4,"jay");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);

        binaryTree.setRoot(root);

        System.out.println("preorder: ");
        binaryTree.preOrder();

        System.out.println("infix order: ");
        binaryTree.infixOrder();

        System.out.println("post order: ");
        binaryTree.postOrder();

    }
}

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

    public void setRoot(HeroNode root) {
        this.root = root;
    }
    // preoder traversal
    public void preOrder(){
        if(this.root!=null){
            this.root.preOrder();
        }else{
            System.out.println("empty binary tree");
        }
    }

    public void infixOrder(){
        if(this.root!=null){
            this.root.infixOrder();
        }else{
            System.out.println("empty");
        }
    }

    public void postOrder(){
        if(this.root!=null){
            this.root.postOrder();
        }else{
            System.out.println("empty");
        }
    }


}


// 节点类

class HeroNode{
    private int id;
    private String name;
    private HeroNode left; // default null
    private HeroNode right;

    public HeroNode(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    // preorder traversal
    public void preOrder(){
        System.out.println(this); // 先输出父节点
        // recurse left tree
        if(this.left!=null){
            this.left.preOrder();
        }
        // recurse right tree
        if(this.right!=null){
            this.right.preOrder();
        }
    }

    // infix order traversal
    public void infixOrder(){
        // recurse left tree
        if(this.left!=null){
            this.left.infixOrder();
        }
        // print father
        System.out.println(this);
        // recurse right
        if(this.right!=null){
            this.right.infixOrder();
        }
    }

    // post-order traversal
    public void postOrder(){
        if(this.left!=null){
            this.left.postOrder();
        }
        if(this.right!=null){
            this.right.postOrder();
        }
        System.out.println(this);
    }
}