顺序存储二叉树

顺序存储二叉树的概念

1. 二叉树的顺序存储结构是把二叉树的所有节点按照一定的次序顺序存储到一组包含N个存储单元的空间中（一般是数组）。在二叉树的顺序存储结构中，只存储节点的值，不存储节点之间的逻辑，节点之间的逻辑关系由数组上下标的顺序来体现。
2. 二叉树的顺序存储原则是：不管给定的二叉树是不是完全二叉树，都看作完全二叉树，即按完全二叉树的层次次序（从上到下，从左到右）把各节点依次存入数组中。
3. 从数据存储来看，数组存储方式和树的存储方式可以互相转换，即在数组可以转换成树，树也可以转成数组 ，看下图
   

顺序存储二叉树的特点

1. 顺序二叉树通常只考虑完全二叉树
2. 第n个元素的左子节点为 2 * n + 1
3. 第n个元素的右子节点为 2 * n + 2
4. 第n个元素的父节点为 (n-1) / 2
5. n : 表示二叉树中的第几个元素(按0开始编号如图所示)，也是数组的下标

• 通过以上的特点可以得出：
  1. 顺序存储二叉树本质上是使用一个数组来存储二叉树的节点数据，
  2. 数组的第n（表示数组的下标）个元素的左子节点的数组 标为2 * n + 1
  3. 数组的第n个元素的右子节点的数组 标为2 * n + 2
  4. 数组的第n个元素的父节点是(n-1)/2
  5. 要满足以上公式的条件是数组下标不能越界

顺序存储二叉树示例

需求: 给你一个数组 {1,2,3,4,5,6,7}，要求以二叉树前序遍历的方式进行遍历。 前序遍历的结果应当为 1,2,4,5,3,6,7

下面是代码实现:

public class ArrayBinaryTree {
    // 存储数据
    private int[] element;

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

    // 重载
    public void preOrder(){
        preOrder(0);
    }

    // 重载
    public void midOrder(){
        midOrder(0);
    }

    // 重载
    public void postOrder(){
        postOrder(0);
    }

    /**
     * 顺序存储二叉树的前序遍历
     * @param index
     */
    private void preOrder(int index) {
        if (index < 0 || index > element.length - 1) {
            return;
        }
        // 先输出该父节点
        System.out.print(element[index] + " ");
        // 在判断该父节点是否有左子节点(即左子节点是否数组越界)，该左子节点下标为2*inde+1
        if (element.length > (2*index + 1)){
            // 表示没有数组越界，则递归查找
            preOrder(2*index + 1);
        }
        // 在判断该父节点是否有右子节点(即左子节点是否数组越界)，该左子节点下标为2*inde+2
        if (element.length > (2*index+2)) {
            // 没有数组越界
            preOrder(2*index+2);
        }
    }

    /**
     * 中序遍历
     * @param index
     */
    public void midOrder(int index) {
        if (index < 0 || index > element.length - 1) {
            return;
        }
        // 先判断该父节点是否有左子节点(即左子节点是否数组越界)，该左子节点下标为2*inde+1
        if (element.length > (2*index + 1)){
            // 表示没有数组越界，则递归查找
            midOrder(2*index + 1);
        }
        // 在输出该节点
        System.out.print(element[index] + " ");
        // 在判断该父节点是否有右子节点(即左子节点是否数组越界)，该左子节点下标为2*inde+2
        if (element.length > (2*index+2)) {
            // 没有数组越界
            midOrder(2*index+2);
        }
    }

    /**
     * 后序遍历
     * @param index
     */
    public void postOrder(int index) {
        if (index < 0 || index > element.length - 1) {
            return;
        }
        // 先判断该父节点是否有左子节点(即左子节点是否数组越界)，该左子节点下标为2*inde+1
        if (element.length > (2*index + 1)){
            // 表示没有数组越界，则递归查找
            postOrder(2*index + 1);
        }
        // 在判断该父节点是否有右子节点(即左子节点是否数组越界)，该左子节点下标为2*inde+2
        if (element.length > (2*index+2)) {
            // 没有数组越界
            postOrder(2*index+2);
        }
        // 最后输出该节点
        System.out.print(element[index] + " ");
    }
}

测试类

public class ArrayBinaryTreeTest {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7};
        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(array);

        System.out.println("前序遍历预计结果是：1，2，4，5，3,6,7");
        arrayBinaryTree.preOrder();
        System.out.println();
        System.out.println("中序遍历预计结果是：4，2，5，1，6，3,7");
        arrayBinaryTree.midOrder();
        System.out.println();
        System.out.println("后序遍历预计结果是：4,5,2，6,7,3，1");
        arrayBinaryTree.postOrder();
    }
}

运行结果

前序遍历预计结果是：1，2，4，5，3,6,7
1 2 4 5 3 6 7 
中序遍历预计结果是：4，2，5，1，6，3,7
4 2 5 1 6 3 7 
后序遍历预计结果是：4,5,2，6,7,3，1
4 5 2 6 7 3 1