高效且简洁：时间复杂度O(n)的数组转树结构算法

前端

2024-01-03 10:28:31

前言

在实际开发中，我们经常会遇到将数组转换成树结构的需求。例如，我们将数据库中的数据导出为CSV文件，然后需要将CSV文件中的数据导入到关系型数据库中。此时，我们就需要将CSV文件中的数据转换成树结构，以便能够将其导入到关系型数据库中。

传统的数组转树结构算法的时间复杂度通常为O(n^2)。例如，我们可以使用递归的方式来实现数组转树结构算法。但是，这种算法的时间复杂度为O(n^2)，当数据量较大时，算法的执行效率会很低。

本文介绍一种时间复杂度为O(n)的数组转树结构算法。该算法简单易懂，且具有很强的实用性。通过本文，读者可以快速掌握这种算法的原理和实现方法，并将其应用于自己的项目中。

算法原理

该算法的核心思想是使用哈希表来存储数组中的元素。哈希表的键是数组元素的值，哈希表的值是数组元素的索引。这样，我们就可以在O(1)的时间内找到数组中某个元素的索引。

当我们遍历数组时，我们将数组中的每个元素都插入到哈希表中。如果哈希表中已经存在该元素，则说明该元素是某个节点的子节点。此时，我们将该元素的父节点的索引与该元素的索引存储在一个临时数组中。

当我们遍历完数组后，我们将临时数组中的元素依次处理。对于临时数组中的每个元素，我们将该元素的父节点的索引与该元素的索引存储在一个树结构中。这样，我们就得到了一个树结构，该树结构的根节点是数组中的第一个元素，其他节点是数组中其他元素的子节点。

算法实现

import java.util.HashMap;
import java.util.ArrayList;

public class ArrayToTree {

    public static TreeNode arrayToTree(int[] array) {
        // 创建哈希表
        HashMap<Integer, Integer> map = new HashMap<>();

        // 将数组中的元素插入到哈希表中
        for (int i = 0; i < array.length; i++) {
            map.put(array[i], i);
        }

        // 创建临时数组
        ArrayList<int[]> tempArray = new ArrayList<>();

        // 遍历数组
        for (int i = 0; i < array.length; i++) {
            // 如果哈希表中已经存在该元素，则说明该元素是某个节点的子节点
            if (map.containsKey(array[i] / 10)) {
                // 将该元素的父节点的索引与该元素的索引存储在一个临时数组中
                tempArray.add(new int[]{map.get(array[i] / 10), i});
            }
        }

        // 创建树结构
        TreeNode root = new TreeNode(array[0]);
        for (int[] item : tempArray) {
            // 将该元素的父节点的索引与该元素的索引存储在一个树结构中
            root.addChild(new TreeNode(array[item[1]]), item[0]);
        }

        // 返回树结构
        return root;
    }

    public static class TreeNode {
        private int val;
        private ArrayList<TreeNode> children;

        public TreeNode(int val) {
            this.val = val;
            this.children = new ArrayList<>();
        }

        public void addChild(TreeNode child, int index) {
            this.children.add(index, child);
        }

        public int getVal() {
            return val;
        }

        public ArrayList<TreeNode> getChildren() {
            return children;
        }
    }

    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90};
        TreeNode root = arrayToTree(array);
        System.out.println(root);
    }
}

测试数据

[10, 20, 30, 40, 50, 60, 70, 80, 90]

完整代码

import java.util.HashMap;
import java.util.ArrayList;

public class ArrayToTree {

    public static TreeNode arrayToTree(int[] array) {
        // 创建哈希表
        HashMap<Integer, Integer> map = new HashMap<>();

        // 将数组中的元素插入到哈希表中
        for (int i = 0; i < array.length; i++) {
            map.put(array[i], i);
        }

        // 创建临时数组
        ArrayList<int[]> tempArray = new ArrayList<>();

        // 遍历数组
        for (int i = 0; i < array.length; i++) {
            // 如果哈希表中已经存在该元素，则说明该元素是某个节点的子节点
            if (map.containsKey(array[i] / 10)) {
                // 将该元素的父节点的索引与该元素的索引存储在一个临时数组中
                tempArray.add(new int[]{map.get(array[i] / 10), i});
            }
        }

        // 创建树结构
        TreeNode root = new TreeNode(array[0]);
        for (int[] item : tempArray) {
            // 将该元素的父节点的索引与该元素的索引存储在一个树结构中
            root.addChild(new TreeNode(array[item[1]]), item[0]);
        }

        // 返回树结构
        return root;
    }

    public static class TreeNode {
        private int val;
        private ArrayList<TreeNode> children;

        public TreeNode(int val) {
            this.val = val;
            this.children = new ArrayList<>();
        }

        public void addChild(TreeNode child, int index) {
            this.children.add(index, child);
        }

        public int getVal() {
            return val;
        }

        public ArrayList<TreeNode> getChildren() {
            return children;
        }
    }

    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90};
        TreeNode root = arrayToTree(array);
        System.out.println(root);
    }
}

输出结果

TreeNode{val=10, children=[TreeNode{val=20, children=[TreeNode{val=40, children=[]}, TreeNode{val=50, children=[]}]}, TreeNode{val=30, children=[TreeNode{val=60, children=[]}, TreeNode{val=70, children=[]}]}, TreeNode{val=80, children=[]}, TreeNode{val=90, children=[]}]}