顺序存储二叉树的前序、中序、后序遍历

顺序存储二叉树

基本说明：

 从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组，看示意图。

要求:

• 如图的二叉树的结点，要求以数组的方式来存放 arr : [1, 2, 3, 4, 5, 6, 7]，要求在遍历数组arr时，仍然可以以前序遍历，中序遍历和后序遍历的方式完成结点的遍历

  顺序存储二叉树的特点:

• 顺序二叉树通常只考虑完全二叉树 第n个元素的左子节点为 2 * n + 1

• 第n个元素的右子节点为 2 * n + 2

• 第n个元素的父节点为 (n-1) / 2

• n : 表示二叉树中的第几个元素(按0开始编号如图所示)

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

//顺序存储二叉树
/**   数组下标 (0)
 *        1
 *       / \
 *      2   3
 *     /\  /\
 *    4 5 6  7
 */
public class ArrayBinaryTree {
    public static void main(String[] args) {
        int []arr={1,2,3,4,5,6,7};
        ArrayTree arrayTree=new ArrayTree(arr);
        //前序遍历测试
        System.out.println("前序遍历：");
        arrayTree.preOrder();//1 2 4 5 3 6 7
        //中序遍历测试
        System.out.println("中序遍历结果");
        arrayTree.infixOrder(0);//4 2 5 1 6 3 7
        //后序遍历测试
        System.out.println("后序遍历结果：");
        arrayTree.postOrder(0);//4 5 2 6 7 3 1
    }
}
//编写一个ArrayBinaryTree，实现顺序存储二叉树遍历
class ArrayTree{
    private int [] arr;//存储数据节点的数组
    public ArrayTree(int [] arr){
        this.arr=arr;
    }
    // 重载一个方法
    public void preOrder(){
        this.preOrder(0);
    }

    //编写一个方法完成顺序存储二叉树的前序遍历

    /**
     *
     * @param index 数组下标
     */
    public void preOrder(int index){
        //如果数组为空
        if(arr==null||arr.length==0){
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        //输出当前数组元素
        System.out.println(arr[index]);
        //向左递归遍历
        if(index*2+1<arr.length){
            preOrder(2*index+1);
        }
        //向右递归
        if(index*2+2<arr.length){
            preOrder(index*2+2);
        }
    }
    //中序遍历
    public void infixOrder(int index){
        //如果数组为空
        if(arr==null||arr.length==0){
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        //向左递归遍历
        if(index*2+1<arr.length){
            infixOrder(2*index+1);
        }
        //输出当前数组元素
        System.out.println(arr[index]);
        //向右递归
        if(index*2+2<arr.length){
            infixOrder(index*2+2);
        }
    }
    //后序遍历
    public void postOrder(int index){
        //如果数组为空
        if(arr==null||arr.length==0){
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        //向左递归遍历
        if(index*2+1<arr.length){
            postOrder(2*index+1);
        }
        //向右递归
        if(index*2+2<arr.length){
            postOrder(index*2+2);
        }
        //输出当前数组元素
        System.out.println(arr[index]);
    }
}

运行结果：

前序遍历：
1
2
4
5
3
6
7
中序遍历结果
4
2
5
1
6
3
7
后序遍历结果：
4
5
2
6
7
3
1
Process finished with exit code 0