二叉树的顺序存储与遍历

二叉树的存储结构目前所学：

1、顺序存储

  概念：采用数组来存储二叉树的所有节点。注意，顺序存储只适用于完全二叉树（满二叉树也是完全二叉树的一种）

  顺序存储的特点

  对于一棵有n个结点的完全二叉树，按照从上至下和从左至右的顺序对所有结点从 0 开始到 n-1 进行顺序编号，则对于索引为    i的结点(0≤i<n)

  （1）如果 i=0，则结点i是二叉树的根
  （2）第 i 个元素的左子节点为 2 * i + 1，如果2i+1≥n，则结点i无左孩子
  （3）第 i 个元素的右子节点为 2 * i + 2，如果2i＋2≥n，则结点i无右孩子
  （4）第 i 个元素的父节点为 (i-1) / 2

  2、链式存储

  概念：每个节点保留一个left，right域，指向左右子节点

  3、顺序存储二叉树的前序遍历、中序遍历、后序遍历的代码实现

  给定一个数组 {1,2,3,4,5,6,7}，要求以二叉树前序、中序、后序遍历的方式进行遍历

package com.zzb.tree;

/**
 * @Auther: Administrator
 * @Date: 2019/10/12 00:43
 * @Description: 给定一个数组 {1,2,3,4,5,6,7}，要求以二叉树前序、中序、后序遍历的方式进行遍历
 */
public class BinaryTreeDemo02 {
    public static void main(String[] args) {
        // 前序遍历
        testPreOrder();
        // 中序遍历
        testInfixOrder();
        // 后序遍历
        testPostOrder();
        /*-------------------前序遍历-------------------
        1	2	4	5	3	6	7
        -------------------中序遍历-------------------
        4	2	5	1	6	3	7
        -------------------后序遍历-------------------
        4	5	2	6	7	3	1*/
    }

    // 测试前序遍历
    public static void testPreOrder() {
        int[] array = {1,2,3,4,5,6,7};
        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(array);
        arrayBinaryTree.preOrder();
    }

    // 测试中序遍历
    public static void testInfixOrder() {
        int[] array = {1,2,3,4,5,6,7};
        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(array);
        arrayBinaryTree.infixOrder();
    }

    // 测试后序遍历
    public static void testPostOrder() {
        int[] array = {1,2,3,4,5,6,7};
        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(array);
        arrayBinaryTree.postOrder();
    }
}

// 顺序存储二叉树的遍历
class ArrayBinaryTree {
    // 存储二叉树节点的数组
    private int[] array;

    public ArrayBinaryTree(int[] array) {
        this.array = array;
    }

    public int[] getArray() {
        return array;
    }

    public void setArray(int[] array) {
        this.array = array;
    }

    // 重载前序遍历
    public void preOrder() {
        System.out.println("-------------------前序遍历-------------------");
        this.preOrder(0);
        System.out.println();
    }

    // 前序遍历
    public void preOrder(int index) {
        if(this.getArray() == null || this.getArray().length == 0) {
            System.out.println("数组为空，不能进行二叉树的前序遍历！");
        }
        // 输出当前索引的节点
        System.out.print(array[index] + "\t");
        // 当前索引的节点存在左子节点
        if(2*index+1 < array.length) {
            preOrder(2*index+1);
        }
        // 当前索引的节点存在右子节点
        if(2*index+2 < array.length) {
            preOrder(2*index+2);
        }
    }

    // 重载中序遍历
    public void infixOrder() {
        System.out.println("-------------------中序遍历-------------------");
        this.infixOrder(0);
        System.out.println();
    }

    // 中序遍历
    public void infixOrder(int index) {
        if(this.getArray() == null || this.getArray().length == 0) {
            System.out.println("数组为空，不能进行二叉树的前序遍历！");
        }
        // 当前索引的节点存在左子节点
        if(2*index+1 < array.length) {
            infixOrder(2*index+1);
        }
        // 输出当前索引的节点
        System.out.print(array[index] + "\t");
        // 当前索引的节点存在右子节点
        if(2*index+2 < array.length) {
            infixOrder(2*index+2);
        }
    }

    // 重载后序遍历
    public void postOrder() {
        System.out.println("-------------------后序遍历-------------------");
        this.postOrder(0);
        System.out.println();
    }

    // 后序遍历
    public void postOrder(int index) {
        if(this.getArray() == null || this.getArray().length == 0) {
            System.out.println("数组为空，不能进行二叉树的前序遍历！");
        }
        // 当前索引的节点存在左子节点
        if(2*index+1 < array.length) {
            postOrder(2*index+1);
        }
        // 当前索引的节点存在右子节点
        if(2*index+2 < array.length) {
            postOrder(2*index+2);
        }
        // 输出当前索引的节点
        System.out.print(array[index] + "\t");
    }
}