用Java实现【顺序存储二叉树】_java掌握二叉树的实现,使用二叉树顺序存储结构和链式存储结构来存储具有5个元素的

建议先实现二叉树

一、什么是顺序存储二叉树

基本说明

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

要求

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开始编号,如图所示)
6. 

二、代码实现

1.前序遍历

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

    public ArrayBinaryTree(int[] array) {
        this.array = array;
    }
	//前序遍历入口
	public void preOrder() {
        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);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2.中序遍历

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

    public ArrayBinaryTree(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);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2.后序遍历

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

    public ArrayBinaryTree(int[] array) {
        this.array = array;
    }
	//后序遍历入口
	public void postOrder() {
        infixOrder(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]+" ");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

启动入口

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

        ArrayBinaryTree tree = new ArrayBinaryTree(array);

        System.out.println("前序");
        tree.preOrder();
        System.out.println();

        System.out.println("中序");
        tree.infixOrder();
        System.out.println();

        System.out.println("后序");
        tree.postOrder();
        System.out.println();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

完整代码下载