数据结构之树（二叉树的存储方式之数组）

合集 - 数据结构与算法(24)

1.算法衡量优劣之时间复杂度2023-09-052.数据结构与算法之概念2023-09-013.算法衡量优劣之空间复杂度2023-09-064.数据结构之数组2023-09-065.数据结构之链表2023-09-116.数据结构之栈2023-09-147.N-皇后问题2023-09-198.算术表达式的表示法（即求值法）2023-09-249.算术表达式求值法（表达式求值）之前序表示法求值2023-09-2510.算术表达式求值法（表达式求值）之后序表示法求值2023-09-2711.数据结构之队列（一般队列）2023-10-0812.数据结构之队列（循环队列）2023-10-1113.数据结构之队列（双向队列）2023-10-1414.数据结构之树（基本概念）2023-10-2415.数据结构之树（二叉树）2023-10-2916.数据结构之树（Huffman tree(赫夫曼树 / 霍夫曼树 / 哈夫曼树 / 最优二叉树)）2023-10-31

17.数据结构之树（二叉树的存储方式之数组）2023-11-02

18.数据结构之树（二叉树的存储方式之链表）2023-11-0519.数据结构之树（遍历）2023-11-0520.数据结构之树（二叉运算树）2023-11-0721.数据结构之树（二叉搜索树）2023-11-0822.数据结构之树（线索树）2023-11-1123.数据结构之树（树转化为二叉树也叫二叉化）2023-11-1224.确定唯一二叉树2023-11-12

收起

存储方式

一般使用数组、链表来存储树（节点）。链表的优点就是添加、删除。数组优点是访问（遍历）。

一维数组表示法

首先将二叉树当作一颗满二叉树（Full Binary Tree），因此第K层具有2^k-1  个节点。按照规则存放在一维数组中。

原理

• 对于一个具有n个节点的二叉树，可以使用一个长度为2n的数组来表示它。通常，数组的索引从0开始。
对于数组中的任意索引 i，如果 i 处的元素表示二叉树的一个节点，那么：
• 节点i的左子节点将位于索引 2i + 1的位置。
• 节点i的右子节点将位于索引 2i + 2的位置。
• 节点i的父节点将位于索引 (i - 1) / 2的位置（如果i不是根节点）。

最佳实践

1. 在数组中表示二叉树时，确保数组的大小足够以容纳树中的所有节点。通常情况下，您需要知道树的大小（节点数）以便创建正确大小的数组。

2. 当使用数组表示树时，树的结构通常是静态的，即不支持插入或删除节点。如果需要经常进行插入和删除操作，使用链表表示法可能更合适。

3. 当数组表示的二叉树是满二叉树时（每个层级都是满的），效果最好。如果树是完全二叉树，效果也不错，但如果树的形状不规则，可能会浪费一些空间。

示例

Java语言

public class ArrayBinaryTree {
    private int[] treeArray;

    public ArrayBinaryTree(int size) {
        treeArray = new int[size];
    }

    public int find(int value) {
        for (int i = 0; i < treeArray.length; i++) {
            if (treeArray[i] == value) {
                return i;
            }
        }
        return -1;
    }

    public void insert(int value) {
        for (int i = 0; i < treeArray.length; i++) {
            if (treeArray[i] == 0) {
                treeArray[i] = value;
                return;
            }
        }
    }

    public void preOrderTraversal(int index) {
        if (index >= treeArray.length || treeArray[index] == 0) {
            return;
        }
        System.out.print(treeArray[index] + " ");
        preOrderTraversal(2 * index + 1); // 左子节点
        preOrderTraversal(2 * index + 2); // 右子节点
    }

    public static void main(String[] args) {
        // 构建数组其实就是构建树（数组索引与树的左右子节点、父节点有关系）
        ArrayBinaryTree tree = new ArrayBinaryTree(10);
        tree.insert(1);
        tree.insert(2);
        tree.insert(3);
        tree.insert(4);
        tree.insert(5);
        // 打印树结构，元素为0的表示是空节点即不存在的节点（空间浪费哦）
        System.out.println("Tree structure:");
        for (int value : tree.treeArray) {
            System.out.print(value + " ");
        }
        // 查找元素
        System.out.println("\nFind value 3 at index: " + tree.find(3));
        // 前序排序
        System.out.println("Pre-order traversal:");
        tree.preOrderTraversal(0);
    }
}

输出：

?

1 2 3 4 5

Tree structure: 1 2 3 4 5 0 0 0 0 0 Find value 3 at index: 2 Pre-order traversal: 1 2 4 5 3

　　

 

 

 python语言实现

class BinaryTree:
    def __init__(self, size):
        self.tree = [None] * size

    '''
    1. 先根节点  0
    2. 左子节点  2 * 0 + 1
    3. 右子节点  2 * 0 + 2
    4. 把第2步的左子节点当作根节点，插入其左、右子节点
    5. 其左子节点 2 * 1 + 1
    6. 其右子节点 2 * 2 + 2
    7. 然后继续按此规律处理即把第5步的左子节点当作根节点继续处理
    '''

    def insert(self, value):
        for i in range(len(self.tree)):
            if self.tree[i] is None:
                self.tree[i] = value
                return

    # 前序遍历: 根节点在左右子树所有节点前面即第1个。然后左子树（当作独立的树）进行处理，左子树遍历完，右子树遍历
    def pre_order(self, index):
        if index >= len(self.tree) or self.tree[index] is None:
            return
        print(self.tree[index])
        self.pre_order(2 * index + 1)
        self.pre_order(2 * index + 2)

    # 中序遍历: 根节点在左右子树的中间（不停的分独立树，直到无法再分为止，然后访问左子树节点（只有1个节点）、其根节点、右子树节点（也是不停分））
    def in_order(self, index):
        if index >= len(self.tree) or self.tree[index] is None:
            return
        self.in_order(2 * index + 1)
        print(self.tree[index])
        self.in_order(2 * index + 2)

    # 后序遍历:道路一样，不停拆树，直到拆不了，就可以处理。处理：左子树节点-->右子树节点-->其根节点
    def post_order(self, index):
        if index >= len(self.tree) or self.tree[index] is None:
            return
        self.post_order(2 * index + 1)
        self.post_order(2 * index + 2)
        print(self.tree[index])


# 创建一个大小为10的二叉树对象
tree = BinaryTree(10)
# 插入节点
tree.insert(1)
tree.insert(2)
tree.insert(3)
tree.insert(4)
tree.insert(5)
# 先序遍历
print("Pre-order traversal:")
tree.pre_order(0)
# 中序遍历
print("In-order traversal:")
tree.in_order(0)
# 后序遍历
print("Post-order traversal:")
tree.post_order(0)

输出：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

Pre-order traversal: 1 2 4 5 3 In-order traversal: 4 2 5 1 3 Post-order traversal: 4 5 2 3 1