常用的Java数据结构知识点汇总
1. 数据结构分类
按照线性和非线性可以将Java数据结构分为两大类：
①线性数据结构：数组、链表、栈、队列
②非线性数据结构：树、堆、散列表、图
2. 线性数据结构
2.1 数组
数组是一种将元素存储于连续内存空间的数据结构，并且要求元素的类型相同。
// 定义一个数组长度为5的数组array int[] array = new int[5]; // 为数组的元素赋值 array[0] = 4; array[1] = 3; array[2] = 2; array[3] = 1; array[4] = 0;
直接赋值：
// 一种方式
int[] array = {4, 3, 2, 1, 0};
// 另一种方式
int[] array = new int[]{4, 3, 2, 1, 0};2.2 可变数组
可变数组是在一般数组的基础上结合扩容机制进行改进的具有灵活长度的数组。
// 定义一个可变数组 List<Integer> changeable_array = new ArrayList<>(); // 向可变数组的尾部添加元素 array.add(4); array.add(3); array.add(2); array.add(1); array.add(0);
2.3 链表
链表可以定义为一个类，该类的包含两个成员变量的：节点的值val、后继节点的引用next。节点是构成链表的基本单位，这种数据结构在内存空间的存储地址是非连续的。
// 定义链表类
class ListNode {
// 节点的值
int val;
// 后继节点的引用
ListNode next;
ListNode(int x){
this. val = x;
}
}构建多个链表类的对象，并构建这些节点实例之间的引用指向：
- ①节点head的节点值为2，其后继节点是值为1的节点n2。
- ②节点n2的节点值为1，其后继节点是值为0的节点n3。
- ③该链表的头节点为head，尾节点为n3。
// 实例化节点 ListNode head = new ListNode(2); ListNode n2 = new ListNode(1); ListNode n3 = new ListNode(0); // 构建三个节点之间的引用指向 head.next = n2; n2.next = n3;
2.4 栈
栈是一种抽象数据结构，特点是“后进先出”，可由数组或者链表实现。
// 定义一个栈，使用Java的Vector类的子类Stack Stack<Integer> stack = new Stack<>();
入栈操作 push()：
// 元素0入栈 stack.push(0); // 元素1入栈 stack.push(1);
出栈操作 pop()：
// 元素1出栈 stack.pop(); // 元素0出栈 stack.pop();
在Java中可以使用Stack、ArrayDeque、LinkedList实现栈，但通常情况下，不推荐使用Vector类以及其子类Stack，
一般使用LinkedList来实现栈：
LinkedList<Integer> stack = new LinkedList<>();
入栈操作 addLast()：
// 元素0入栈 stack.addLast(0); // 元素1入栈 stack.addLast(1);
出栈操作 removeLast()：
// 元素1出栈 stack.removeLast(); // 元素0入栈 stack.removeLast();
2.5 队列
队列是一种抽象数据结构，特点是“先进先出”，可由链表实现。LinkedList类实现了Queue接口，因此可以把LinkedList当成Queue来用。
Queue<Integer> queue = new LinkedList<>();
入队操作 offer()：
// 元素0入队 queue.offer(0); // 元素1入队 queue.offer(1);
出队操作poll()，该函数的返回值为出队的那个元素：
// 元素0出队 queue.poll(); // 元素1出队 queue.poll();
element()：返回第一个元素
peek()：返回第一个元素
区别：在队列元素为空的情况下，element() 方法会抛出NoSuchElementException异常，peek() 方法只会返回 null。
queue.offer("a");
queue.offer("b");
queue.offer("c");
queue.offer("d");
queue.offer("e");
queue.element(); //输出a
queue.peek(); //输出a3. 非线性数据结构
3.1 树
树是一种非线性的数据结构，可分为二叉树和多叉树。
二叉树可定义为一个类，该类包含三个成员变量：节点值val、左子节点left、右子节点right。
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x){
this.val = x;
}
}二叉树各节点实例化：
// 根节点root TreeNode root = new TreeNode(0); TreeNode n2 = new TreeNode(1); TreeNode n3 = new TreeNode(2); TreeNode n4 = new TreeNode(3); TreeNode n5 = new TreeNode(4);
构建二叉树各节点之间的引用指向：
// 根节点的左子节点为n2，其值为1 root.left = n2; // 根节点的右子节点为n3，其值为2 root.right = n3; // 节点n2的左子节点为n4，其值为3 n2.left = n4; // 节点n2的右子节点为n5，其值为4 n2.right = n5;
3.2 图
图是一种非线性数据结构，由顶点（vertex）和边（edge）组成，每条边都连接着两个顶点。
图分为有向图和无向图。
以无向图为例：
- ①顶点集合： vertices = {1, 2, 3, 4, 5}
- ②边集合： edges = {(1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (3, 5), (4, 5)}
（1）图的表示方法：邻接矩阵（无向图的邻接矩阵是一个斜对角对称矩阵）
⭐邻接矩阵适用于存储稠密图，即顶点较多、边较少。
// 存储图的顶点
int[] vertices = {1, 2, 3, 4, 5};
// 存储图的边
int[][] edges = {{0, 1, 1, 1, 1},
{1, 0, 0, 1, 0},
{1, 0, 0, 0, 1},
{1, 1, 0, 0, 1},
{1, 0, 1, 1, 0}};
int[] vertices = {1, 2, 3, 4, 5};（2）图的表示方法：邻接表
⭐邻接表适用于存储稀疏图，即顶点多、边较少。
// 存储图的顶点
int[] vertices = {1, 2, 3, 4, 5};
// 存储边的集合
List<List<Integer>> edges = new ArrayList<>();
// edge[i]表示图的顶点i对应的边集合
List<Integer> edge_1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
List<Integer> edge_2 = new ArrayList<>(Arrays.asList(0, 3));
List<Integer> edge_3 = new ArrayList<>(Arrays.asList(0, 4));
List<Integer> edge_4 = new ArrayList<>(Arrays.asList(0, 1, 4));
List<Integer> edge_5 = new ArrayList<>(Arrays.asList(0, 2, 3));
edges.add(edge_1);
edges.add(edge_2);
edges.add(edge_3);
edges.add(edge_4);
edges.add(edge_5);3.3 散列表
散列表是一种非线性的数据结构，实质是将键（key）通过Hash函数完成到值（value）的映射。
// 初始化散列表 Map<String, Integer> dict = new HashMap<>();
添加键 - 值对：
dict.put("python", 101);
dict.put("c", 102);
dict.put("java", 103);通过键 key查找对应的值 value：
dict.get("python"); // 101
dict.get("c"); // 102
dict.get("java"); // 103设计一个简单的Hash函数构建 编程语言 ==> 编号 的映射，构建一个散列表（假设不考虑低碰撞率、高鲁棒性）：
String[] program_lang = {"python", "c", "java"};
int hash(int idx){
int index = (idx -1 % 100);
return index;
}
names[hash(101)]; // python
names[hash(101)]; // c
names[hash(101)]; // java3.4 堆
- （1）堆是一种基于完全二叉树的数据结构，可由数组实现。
- 完全二叉树：一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1 ≤ i ≤ n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。
- （2）基于堆的原理实现的排序算法称为堆排序。
- （3）基于堆实现的数据结构称为优先队列。
- （4）堆分为大顶堆、小顶堆：①大顶堆：任意节点的值不大于其父节点的值，即根节点最大，任意子节点小于等于父节点。②小顶堆：任意节点的值不小于其父节点的值，即根节点最小，任意子节点大于等于父节点。
// 初始化小顶堆，操作为 优先队列 Queue<Integer> heap = new PriorityQueue<>();
元素入堆add()：
// 元素入堆 heap.add(0); heap.add(4); heap.add(2); heap.add(6); heap.add(8);
元素出堆 poll()：
// 元素出堆（从小到大） heap.poll(); // -> 0 heap.poll(); // -> 2 heap.poll(); // -> 4 heap.poll(); // -> 6 heap.poll(); // -> 8
到此这篇关于常用的Java数据结构知识点汇总的文章就介绍到这了,更多相关常用的Java数据结构分享内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
函数式接口在Java中是指有且仅有一个抽象方法的接口。当然接口中可以包含其他的方法默认、静态、私有，具体内容请参考下面文章内容2021-09-09
这篇文章主要介绍了SpringBoot中web项目推荐目录结构的问题，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下2022-01-01
RabbitMQ开启SSL与SpringBoot连接测试的配置方法
本文基于 CentOS 7 + Git + OpenSSL + yum 安装的 RabbitMQ，需要读者提交安装好。其他方式也可变通参考本文。对RabbitMQ开启SSL与SpringBoot连接测试相关知识感兴趣的朋友一起看看吧2022-01-01
RandomAccessFile简介_动力节点Java学院整理
RandomAccessFile 是随机访问文件(包括读/写)的类。它支持对文件随机访问的读取和写入，即我们可以从指定的位置读取/写入文件数据。这篇文章主要介绍了RandomAccessFile简介,需要的朋友可以参考下2017-05-05
这篇文章主要介绍了IDEA项目的依赖(pom.xml文件)导入问题及解决，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2020-08-08
在公司项目中,如果需要做一些公共的功能,如日志等,最好的方式是使用自定义注解,自定义注解可以实现我们对想要添加日志的方法上添加,这篇文章基于日志功能来讲讲自定义注解应该如何开发和使用,需要的朋友可以参考下2023-08-08
这篇文章主要给大家介绍了关于如何利用Java输出链表中倒数第k个结点的相关资料,文中通过实例代码介绍的非常详细,对大家学习或者使用java具有一定的参考学习价值,需要的朋友可以参考下2021-12-12
这篇文章主要介绍了Java 确保某个BeanDefinitionRegistryPostProcessor Bean被最后执行的几种实现方式，帮助大家更好的理解和学习使用Java，感兴趣的朋友可以了解下2021-03-03
这篇文章主要介绍了Java中使用正则表达式实现字符串匹配，字符串查找，匹配，替换，正则无不能做，特别是灵活的运用子串匹配，感兴趣的小伙伴们可以参考一下2015-12-12
下面小编就为大家分享一篇让JPA的Query查询接口返回Map对象的方法，具有很的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2017-12-12
最新评论