【递归】二叉树的前序遍历、中序遍历、后序遍历（顺序存储实现）

什么是顺序存储二叉树

一定要看到最后欧

基本说明

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

要求：

 1.二叉树的结点能够以数组的方式来存放 arr: [1,2,3,4,5,6,7];

2.遍历数组时能够以前序遍历，中序遍历，后序遍历的方式遍历出所有结点

特点

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

 

 代码实现

这里我创建类封装了每一个方法

1.前序遍历

递归遍历，若二叉树为空，则什么也不做，否则：

1.访问根节点

2.先序遍历左子树

3.先序遍历右子树

package Tree;

public class PreOrder {
        //存储数据节点的数组
        private int[] array;

        public PreOrder(int[] array) {
            this.array = array;
        }
        //前序遍历入口
        public void preOrder() {
            //调用preOrder(int index);
            preOrder(0);
        }
        /**
         * 前序遍历
         * @param index
         */
        public void preOrder(int index) {
            //如果数组为空或数组.length==0
            if (array == null || array.length == 0) {
                System.out.println("数组为空，不能按照二叉树的前序遍历！");
            }
            //输出当前元素
            System.out.print(array[index]+" ");
            //前序遍历特点：从上至下，从左至右

            //向左递归遍历，左子树
            if ((index * 2 + 1) < array.length) {
                preOrder(2 * index + 1);
            }
            //向右递归遍历，右子树
            if ((index * 2 + 2) < array.length) {
                preOrder(2 * index + 2);
            }
        }

    }

图解递归（由于图片大小问题，建议用电脑端放大查看，以下图解也是）

2.中序遍历

递归遍历，若二叉树为空，则什么也不做，否则：

1.中序遍历左子树

2.访问根节点

3.中序遍历右子树

package Tree;

public class InfixOrder {
        //存储数据节点的数组
        private int[] array;

        public InfixOrder(int[] array) {
            this.array = array;
        }
        //中序遍历入口
        public void infixOrder() {
            infixOrder(0);
        }

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

    }

3.后序遍历

递归遍历，若二叉树为空，则什么也不做，否则：

1.后序遍历左子树

3.后序遍历右子树

2.访问根节点

package Tree;

public class PostOrder {
        //存储数据节点的数组
        private int[] array;

        public PostOrder(int[] array) {
            this.array = array;
        }
        //后序遍历入口
        public void postOrder() {
            postOrder(0);
        }

        /**
         * 后序遍历
         * @param index
         */
        private void postOrder(int index) {
            //如果数组为空或数组.length==0
            if (array == null || array.length == 0) {
                System.out.println("数组为空，不能按照二叉树的前序遍历！");
            }
            //向左递归遍历
            if ((index * 2 + 1) < array.length) {
                postOrder(2 * index + 1);
            }

            //向右递归遍历
            if ((index * 2 + 2) < array.length) {
                postOrder(2 * index + 2);
            }

            //输出当前这个元素
            System.out.print(array[index]+" ");
        }

    }

4.测试类

package Tree;
        /*
        先了解顺序存储二叉树的特点
        顺序二叉树的实现用完全二叉树的特性
        第n个元素的左子结点为2n+1
        第n个元素的右子结点为2n+2
        第n个元素的父结点为（n+1）/2
        n代表二叉树的第几个元素，从0开始（和数组一样）
        (index * 2 + 1) < arr.length 表示为左部分
        (index * 2 + 2) < arr.length表示为右部分
        */

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

            PreOrder pre=new PreOrder(array);
            InfixOrder infix=new InfixOrder(array);
            PostOrder post=new PostOrder(array);

            System.out.println("前序遍历");
            pre.preOrder();
            System.out.println();

            System.out.println("中序遍历");
            infix.infixOrder();
            System.out.println();

            System.out.println("后序遍历");
            post.postOrder();
            System.out.println();
        }

}

 很多小伙伴可能会觉得：哇！这么少的代码就可以解决了吗？对，就是这么几行，这也就是递归遍历的强大之处。但是这之间的递归过程是很复杂的。