【数据结构与算法】Java中的基本数据结构：数组、链表、树、图、散列表等。

Dylanioucn

于 2024-10-23 07:00:00 发布

阅读量2.1k

点赞数 49

文章标签：数据结构 java 链表

本文链接：https://blog.csdn.net/u010425839/article/details/143170560

版权

探索Java集合框架：数据结构的精髓与应用

摘要：
在本文中，我们将深入探讨Java集合框架中的核心数据结构，包括数组、链表、树、图、散列表、栈、队列、集合、映射和优先队列。通过分析每种数据结构的实现原理和特点，你将学会如何根据具体需求选择合适的数据结构，从而提升程序的性能和效率。文章还包含了Java代码示例和流程图，帮助你更好地理解和应用这些数据结构。

关键词：
Java集合框架、数据结构、数组、链表、树、图、散列表、栈、队列、集合、映射、优先队列

1. 数组（Array）

实现原理

数组是一种线性数据结构，使用连续的内存空间存储固定大小的元素。

特点

访问速度快（O(1)时间复杂度）
大小固定，不支持动态扩展

Java代码示例：

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println("Array element at index 0: " + numbers[0]);
    }
}

2. 链表（LinkedList）

实现原理

链表由一系列节点组成，每个节点包含数据部分和指向下一个（或上一个，对于双向链表）节点的指针。

特点

支持动态扩展
插入和删除操作较快（O(1)时间复杂度，如果已知节点位置）
访问特定元素较慢（O(n)时间复杂度）

Java代码示例：

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println("LinkedList contains: " + list);
    }
}

3. 树（Tree）

实现原理

树是一种层次结构，每个节点有零个或多个子节点。常见的树结构有二叉树、平衡二叉树（如AVL树）、红黑树等。

特点

树结构可以用于实现高效的查找、插入和删除操作（通常为O(log n)时间复杂度）

Java代码示例：

// 树的实现较为复杂，通常使用第三方库，如Apache Commons Collections

4. 图（Graph）

实现原理

图由顶点（节点）和边组成，可以表示复杂的关系。图的表示方法有邻接矩阵和邻接表两种。

特点

适用于表示网络、路径等复杂关系
查找特定路径或循环可能需要较复杂的算法

Java代码示例：

// 图的实现较为复杂，通常使用第三方库，如JGraphT

5. 散列表（Hash Table）

实现原理

散列表通过哈希函数将键映射到表中的位置来访问数据，通常使用数组实现。

特点

在理想情况下，支持平均常数时间复杂度的查找、插入和删除操作
在最坏情况下，性能可能下降到O(n)

Java代码示例：

import java.util.HashMap;

public class HashTableExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        System.out.println("Hash Table contains: " + map);
    }
}

6. 栈（Stack）

实现原理

栈是一种后进先出（LIFO）的数据结构，通常使用数组或链表实现。

特点

支持快速的压栈（push）和弹栈（pop）操作

Java代码示例：

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        System.out.println("Stack top element: " + stack.pop());
    }
}

7. 队列（Queue）

实现原理

队列是一种先进先出（FIFO）的数据结构，可以基于数组或链表实现。

特点

支持快速的入队（enqueue）和出队（dequeue）操作

Java代码示例：

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.add(2);
        System.out.println("Queue front element: " + queue.poll());
    }
}

8. 集合（Set）

实现原理

集合是一个不允许重复元素的无序集合，通常使用哈希表实现。

特点

提供快速的元素查找和插入操作
自动处理重复元素

Java代码示例：

import java.util.HashSet;

public class SetExample {
    public static void main(String[] args) {
        HashSet<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(1); // Duplicate, will not be added
        System.out.println("Set contains: " + set);
    }
}

9. 映射（Map）

实现原理

映射是键值对的集合，通常使用哈希表实现。

特点

支持通过键快速访问值
提供键和值的迭代

Java代码示例：

import java.util.Map;
import java.util.HashMap;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        System.out.println("Map contains: " + map);
    }
}

10. 优先队列（Priority Queue）

实现原理

优先队列是一种特殊的队列，元素按照优先级排序，通常使用堆实现。

特点

支持快速的插入和删除操作
访问具有最高优先级的元素

Java代码示例：

import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> queue = new PriorityQueue<>();
        queue.add(1);
        queue.add(3);
        queue.add(2);
        System.out.println("Priority Queue poll: " + queue.poll());
    }
}

数据结构对比

数据结构	访问速度	插入速度	删除速度	动态扩展	允许重复
数组	O(1)	O(1)	O(1)	否	是
链表	O(n)	O(1)	O(1)	是	是
树	O(log n)	O(log n)	O(log n)	是	是
图	复杂	复杂	复杂	是	是
散列表	平均O(1)	平均O(1)	平均O(1)	是	是
栈	O(1)	O(1)	O(1)	是	否
队列	O(n)	O(1)	O(1)	是	否
集合	O(1)	O(1)	O(1)	是	否
映射	O(1)	O(1)	O(1)	是	否
优先队列	O(n)	O(log n)	O(log n)	是	是