数组，链表，红黑树介绍以及性能对比实验

作者：晓宜
🌈🌈🌈
个人简介：携程javaer，阿里云专家博主，csdn后端优质创作者，算法爱好者
❤️❤️❤️
一起进步！！！😊

前言

以前学了数组，链表，红黑树的相关知识，今天用Java对它们三者在插入，删除，查找等方面做一个性能对比测试，今天分享给大家😊

数据结构

1. ArrayList

ArrayList底层是基于动态数组实现的。其特点包括：

数据结构：动态数组。
访问时间：通过索引访问元素的时间复杂度为O(1)，因为可以直接通过索引定位到元素。
插入和删除：在尾部插入元素的时间复杂度为O(1)。在中间插入或删除元素的时间复杂度为O(n)，因为需要移动元素来保持数组的连续性。
扩容机制：当数组容量不够时，ArrayList会创建一个更大的数组（通常是原容量的1.5倍左右），然后将旧数组中的元素复制到新数组中。

2.LinkedList

LinkedList底层是基于双向链表实现的。其特点包括：

数据结构：双向链表，每个节点包含一个数据元素以及指向前后节点的引用。
访问时间：访问元素的时间复杂度为O(n)，因为需要从头节点或尾节点遍历链表找到目标节点。
插入和删除：在链表头部或尾部插入和删除元素的时间复杂度为O(1)。在链表中间插入和删除元素的时间复杂度为O(n)，因为需要先遍历找到插入或删除位置。
灵活性：适用于频繁插入和删除操作的场景，但随机访问效率较低。

3. TreeMap

TreeMap底层是基于红黑树（Red-Black Tree）实现的。其特点包括：

数据结构：红黑树，一种自平衡的二叉搜索树。
访问时间：查找、插入和删除操作的时间复杂度为O(log n)，因为红黑树在最坏情况下的高度为O(log n)。
键排序：TreeMap中的元素按照键的自然顺序或指定的比较器排序。
有序性：提供按键值排序的特性，可以方便地进行范围查询和有序遍历。

实验代码

我们先讲一下代码具体做了些什么，在代码中，我创造了三个函数，分别对应三个数据结构：数组，链表，红黑树。在每个函数中，我会先创建这样一个数据结构对象和一个随机数对象，接下来执行三步：

1. 用随机数对象生成1000个随机数，先插入到刚才生成的数据结构中，计算时间
2. 生成1000个随机数，在数据结构中查找是否存在这个数，计算时间
3. 生成1000个随机数，随机生成一个索引，删除这个索引对应的数，计算时间

这里是其中一次测试的结果：

在这次测试中，我们发现红黑树的查找和删除性能是最优秀的，但是其插入的效率是最低的，这是因为他在插入过程中需要构建红黑树的结构；链表的插入，查询和删除效率都是最低的；数组插入，删除，查询的效率居中。感兴趣的小伙伴可以自己做这样一个实验😎，代码如下：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Random;
import java.util.TreeMap;

public class PerformanceTest {

    public static void RedBlack(ArrayList<Integer> testList) {
        // 创建 TreeMap
        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
        Random random = new Random();
        int dataSize = testList.size(); // 数据规模

        // 生成随机数据并插入
        long startTime = System.nanoTime();
        for (int i = 0; i < dataSize; i++) {
            int key = random.nextInt(dataSize); // 随机生成键
            int value = testList.get(i); // 随机生成值
            treeMap.put(key, value);
        }
        long insertTime = System.nanoTime() - startTime;

        // 随机查找
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int key = random.nextInt(dataSize); // 随机生成键
            treeMap.containsKey(key);
        }
        long searchTime = System.nanoTime() - startTime;

        // 随机删除
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int key = random.nextInt(dataSize); // 随机生成键
            treeMap.remove(key);
        }
        long deleteTime = System.nanoTime() - startTime;

        // 打印时间
        System.out.println("Insertion time: " + insertTime / 1000000.0 + " ms");
        System.out.println("Search time: " + searchTime / 1000000.0 + " ms");
        System.out.println("Deletion time: " + deleteTime / 1000000.0 + " ms");
    }

    public static void Linkedlist(ArrayList<Integer> testList) {
        // 数据规模
        int dataSize = testList.size();
        // 创建链表
        LinkedList<Integer> linkedList = new LinkedList<>();
        // 随机数生成器
        Random random = new Random();

        // 生成随机数据并插入
        long startTime = System.nanoTime();
        for (int i = 0; i < dataSize; i++) {
            linkedList.add(testList.get(i)); // 随机生成数据并插入链表
        }
        long insertTime = System.nanoTime() - startTime;

        // 随机查找1000次，计算查找时间
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int randomData = random.nextInt(); // 随机生成数据
            boolean found = linkedList.contains(randomData); // 查找数据
        }
        long searchTime = System.nanoTime() - startTime;

        // 随机删除1000次，计算删除时间
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int randomIndex = random.nextInt(linkedList.size()); // 随机生成索引
            linkedList.remove(randomIndex); // 删除元素
        }
        long deleteTime = System.nanoTime() - startTime;

        // 打印时间
        System.out.println("Insertion time: " + insertTime / 1000000.0 + " ms");
        System.out.println("Search time: " + searchTime / 1000000.0 + " ms");
        System.out.println("Deletion time: " + deleteTime / 1000000.0 + " ms");
    }

    public static void ArrayList(ArrayList<Integer> testList) {
        // 数据规模
        int dataSize = testList.size();
        // 创建ArrayList
        ArrayList<Integer> arrayList = new ArrayList<>();
        // 随机数生成器
        Random random = new Random();

        // 生成随机数据并插入
        long startTime = System.nanoTime();
        for (int i = 0; i < dataSize; i++) {
            arrayList.add(testList.get(i)); // 随机生成数据并插入ArrayList
        }
        long insertTime = System.nanoTime() - startTime;

        // 随机查找1000次，计算查找时间
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int randomValue = random.nextInt(); // 随机生成值
            boolean found = arrayList.contains(randomValue); // 查找值是否存在
        }
        long searchTime = System.nanoTime() - startTime;

        // 随机删除1000次，计算删除时间
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int randomIndex = random.nextInt(arrayList.size()); // 随机生成索引
            arrayList.remove(randomIndex); // 删除元素
        }
        long deleteTime = System.nanoTime() - startTime;

        // 打印时间
        System.out.println("Insertion time: " + insertTime / 1000000.0 + " ms");
        System.out.println("Search time: " + searchTime / 1000000.0 + " ms");
        System.out.println("Deletion time: " + deleteTime / 1000000.0 + " ms");
    }

    public static void main(String[] args) {
        // 数据规模
        int dataSize = 1_000_000;
        // 创建ArrayList
        ArrayList<Integer> testList = new ArrayList<>();
        // 随机数生成器
        Random random = new Random();

        for (int i = 0; i < dataSize; i++) {
            testList.add(random.nextInt()); // 随机生成数据并插入
        }

        ArrayList(testList);
        System.out.println("ArrayList done\n");

        Linkedlist(testList);
        System.out.println("LinkedList done\n");

        RedBlack(testList);
        System.out.println("RedBlack done\n");

    }
}

项目链接：

代码链接