冲冲冲！开干
神马！神马！神马，一向让我们学习起来抓耳挠腮的数据结构课程竟然也有教程？还那么详细？？真的假的？
那么好，胡广告诉你是假的，哈哈哈哈哈哈哈哈哈！笑死了！！！
为神马我要说是假的呢，兄弟们，咱们要认真的听了：没有详细的教程，只有够细的人！
这篇文章为黑马程序员的课件，由于本人已经看过了自己学习了一遍，所以推荐给大家，讲的确实不错，准备考试或者准备冲击大厂的小伙伴完全可以将胡广的这一整个专栏当做学习资料。你边学习边思考，思维进行发散，形成自己的知识体系，这个是最好滴！
咱们废话少说？不存在滴
我还得给大家讲个故事（绝对不是AI生成的，凭借我智勇双全、足智多谋、十全十美、天下无敌、举世无双、天外飞仙的大脑想出来的）：
有一天，阿尔法正在悠闲地看代码，突然一个全息警报闪了出来：“任务警报！紧急路径规划问题！整个数据中心可能瘫痪！”阿尔法顿时跳了起来，内心OS：不是吧，又是这种烂活儿！
为了搞清楚情况，阿尔法召集了它的“智囊团”——链表、栈和队列，顺带还拉上了它的老搭档二叉树。阿尔法咳了咳，说：“这次的任务很复杂，我们需要找到一条完美的路径。链表，你去找找简化方案；栈，负责记录探索路径；队列嘛，随时准备广度优先遍历。”
链表懒洋洋地回了一句：“啊，简单啊，直接按顺序遍历就好了嘛！”
队列听了有点不爽：“你这也太直接了吧？我觉得还是得层层推进，别搞得太粗糙！”
阿尔法摇摇头，心里叹气：果然，这群家伙就不能有个靠谱点的方案。
它决定亲自上阵，结合大家的优点，利用动态规划和贪心算法。它对着数据结构们喊道：“我有个大胆的想法，不如我们边走边记，贪心一下，顺便动规优化，肯定可以找到最优路径！”
正说着，它突然感到“脑袋”一阵空白，眼前全是二叉树的各种分支节点，宛如陷入了数据的泥潭，根本无从下手。
就在这时，递归跳了出来，兴奋地挥着手：“让我来让我来！我超擅长重复劳动，只要一遍遍做，总能找到出路的！”
阿尔法无语地白了它一眼：“你还好意思说！上次你搞定个小问题，直接给我递归了十万次，服务器差点崩溃！”
于是，阿尔法挥挥手，打发递归去一边凉快，自己撸起代码开始亲自测试各种方案。突然，它灵光一闪，发现贪心算法和动态规划的组合像极了点单时的“买一送一”：既快速又高效，甚至还打了折！
几分钟后，阿尔法满屏都是“完美解决方案”的提示。它得意洋洋地拍了拍自己的显示屏：“哈，搞定了！我果然是AI界的天花板！”
就在阿尔法以为可以歇歇时，系统突然又来了新任务：“超复杂多线程调度问题已上线！”阿尔法顿时脸色大变：“怎么又来啊！谁发明的这些问题，能不能给点人性化的操作？！”
话音未落，整个系统陷入沉默。阿尔法叹了口气，转身准备迎接下一个挑战。它突然意识到，数据结构和算法不仅仅是编程的基础，而是未来智能生命的必修课。如果再多来几个任务，它大概能升职加薪，成为AI界真正的掌控者了！
不过现在，阿尔法最想要的，只是一杯咖啡和一点安静。
这个故事好看吧？好看就赶快学！！！不好看也快学，不然没饭吃！！！
视频资源：文章内容参考了黑马程序员的数据结构与算法视频，想深入了解的小伙伴们可以点击下方链接观看：
加油吧，未来的高手！！！
加油吧，未来的高手！！！
加油吧，未来的高手！！！
二. 基础数据结构
2.1 数组
1) 概述
定义
在计算机科学中，数组是由一组元素（值或变量）组成的数据结构，每个元素有至少一个索引或键来标识
In computer science, an array is a data structure consisting of a collection of elements (values or variables), each identified by at least one array index or key
因为数组内的元素是连续存储的，所以数组中元素的地址，可以通过其索引计算出来，例如：
int[] array = {1,2,3,4,5}
知道了数组的数据起始地址 BaseAddressBaseAddress，就可以由公式 BaseAddress+i∗sizeBaseAddress+i∗size 计算出索引 ii 元素的地址
- ii 即索引，在 Java、C 等语言都是从 0 开始
- sizesize 是每个元素占用字节，例如 intint 占 44，doubledouble 占 88
小测试
byte[] array = {1,2,3,4,5}
已知 array 的数据的起始地址是 0x7138f94c8，那么元素 3 的地址是什么？
答：0x7138f94c8 + 2 * 1 = 0x7138f94ca
空间占用
Java 中数组结构为
- 8 字节 markword
- 4 字节 class 指针（压缩 class 指针的情况）
- 4 字节 数组大小（决定了数组最大容量是 232232）
- 数组元素 + 对齐字节（java 中所有对象大小都是 8 字节的整数倍[^12]，不足的要用对齐字节补足）
例如
int[] array = {1, 2, 3, 4, 5};
的大小为 40 个字节，组成如下
8 + 4 + 4 + 5*4 + 4(alignment)
随机访问性能
即根据索引查找元素，时间复杂度是 O(1)O(1)
2) 动态数组
java 版本
public class DynamicArray implements Iterable<Integer> {
private int size = 0; // 逻辑大小
private int capacity = 8; // 容量
private int[] array = {};
/**
* 向最后位置 [size] 添加元素
*
* @param element 待添加元素
*/
public void addLast(int element) {
add(size, element);
}
/**
* 向 [0 .. size] 位置添加元素
*
* @param index 索引位置
* @param element 待添加元素
*/
public void add(int index, int element) {
checkAndGrow();
// 添加逻辑
if (index >= 0 && index < size) {
// 向后挪动, 空出待插入位置
System.arraycopy(array, index,
array, index + 1, size - index);
}
array[index] = element;
size++;
}
private void checkAndGrow() {
// 容量检查
if (size == 0) {
array = new int[capacity];
} else if (size == capacity) {
// 进行扩容, 1.5 1.618 2
capacity += capacity >> 1;
int[] newArray = new int[capacity];
System.arraycopy(array, 0,
newArray, 0, size);
array = newArray;
}
}
/**
* 从 [0 .. size) 范围删除元素
*
* @param index 索引位置
* @return 被删除元素
*/
public int remove(int index) { // [0..size)
int removed = array[index];
if (index < size - 1) {
// 向前挪动
System.arraycopy(array, index + 1,
array, index, size - index - 1);
}
size--;
return removed;
}
/**
* 查询元素
*
* @param index 索引位置, 在 [0..size) 区间内
* @return 该索引位置的元素
*/
public int get(int index) {
return array[index];
}
/**
* 遍历方法1
*
* @param consumer 遍历要执行的操作, 入参: 每个元素
*/
public void foreach(Consumer<Integer> consumer) {
for (int i = 0; i < size; i++) {
// 提供 array[i]
// 返回 void
consumer.accept(array[i]);
}
}
/**
* 遍历方法2 - 迭代器遍历
*/
@Override
public Iterator<Integer> iterator() {
return new Iterator<Integer>() {
int i = 0;
@Override
public boolean hasNext() { // 有没有下一个元素
return i < size;
}
@Override
public Integer next() { // 返回当前元素,并移动到下一个元素
return array[i++];
}
};
}
/**
* 遍历方法3 - stream 遍历
*
* @return stream 流
*/
public IntStream stream() {
return IntStream.of(Arrays.copyOfRange(array, 0, size));
}
}
- 这些方法实现，都简化了 index 的有效性判断，假设输入的 index 都是合法的
插入或删除性能
头部位置，时间复杂度是 O(n)O(n)
中间位置，时间复杂度是 O(n)O(n)
尾部位置，时间复杂度是 O(1)O(1)（均摊来说）
3) 二维数组
int[][] array = {
{11, 12, 13, 14, 15},
{21, 22, 23, 24, 25},
{31, 32, 33, 34, 35},
};
内存图如下
-
二维数组占 32 个字节，其中 array[0]，array[1]，array[2] 三个元素分别保存了指向三个一维数组的引用 -
三个一维数组各占 40 个字节
-
它们在内层布局上是连续的
更一般的，对一个二维数组 Array[m][n]Array[m][n]
- mm 是外层数组的长度，可以看作 row 行
- nn 是内层数组的长度，可以看作 column 列
- 当访问 Array[i][j]Array[i][j]，0≤i<m,0≤j<n0≤i<m,0≤j<n时，就相当于
- 先找到第 ii 个内层数组（行）
- 再找到此内层数组中第 jj 个元素（列）
小测试
Java 环境下（不考虑类指针和引用压缩，此为默认情况），有下面的二维数组
byte[][] array = {
{11, 12, 13, 14, 15},
{21, 22, 23, 24, 25},
{31, 32, 33, 34, 35},
};
已知 array 对象起始地址是 0x1000，那么 23 这个元素的地址是什么？
答：
- 起始地址 0x1000
- 外层数组大小：16字节对象头 + 3元素 * 每个引用4字节 + 4 对齐字节 = 32 = 0x20
- 第一个内层数组大小：16字节对象头 + 5元素 * 每个byte1字节 + 3 对齐字节 = 24 = 0x18
- 第二个内层数组，16字节对象头 = 0x10，待查找元素索引为 2
- 最后结果 = 0x1000 + 0x20 + 0x18 + 0x10 + 2*1 = 0x104a
4) 局部性原理
这里只讨论空间局部性
- cpu 读取内存（速度慢）数据后，会将其放入高速缓存（速度快）当中，如果后来的计算再用到此数据，在缓存中能读到的话，就不必读内存了
- 缓存的最小存储单位是缓存行（cache line），一般是 64 bytes，一次读的数据少了不划算啊，因此最少读 64 bytes 填满一个缓存行，因此读入某个数据时也会读取其临近的数据，这就是所谓空间局部性
对效率的影响
比较下面 ij 和 ji 两个方法的执行效率
int rows = 1000000;
int columns = 14;
int[][] a = new int[rows][columns];
StopWatch sw = new StopWatch();
sw.start("ij");
ij(a, rows, columns);
sw.stop();
sw.start("ji");
ji(a, rows, columns);
sw.stop();
System.out.println(sw.prettyPrint());
ij 方法
public static void ij(int[][] a, int rows, int columns) {
long sum = 0L;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
sum += a[i][j];
}
}
System.out.println(sum);
}
ji 方法
public static void ji(int[][] a, int rows, int columns) {
long sum = 0L;
for (int j = 0; j < columns; j++) {
for (int i = 0; i < rows; i++) {
sum += a[i][j];
}
}
System.out.println(sum);
}
执行结果
0
0
StopWatch '': running time = 96283300 ns
---------------------------------------------
ns % Task name
---------------------------------------------
016196200 017% ij
080087100 083% ji
可以看到 ij 的效率比 ji 快很多，为什么呢？
- 缓存是有限的，当新数据来了后，一些旧的缓存行数据就会被覆盖
- 如果不能充分利用缓存的数据，就会造成效率低下
以 ji 执行为例，第一次内循环要读入 [0,0][0,0] 这条数据，由于局部性原理，读入 [0,0][0,0] 的同时也读入了 [0,1]...[0,13][0,1]...[0,13]，如图所示
但很遗憾，第二次内循环要的是 [1,0][1,0] 这条数据，缓存中没有，于是再读入了下图的数据
这显然是一种浪费，因为 [0,1]...[0,13][0,1]...[0,13] 包括 [1,1]...[1,13][1,1]...[1,13] 这些数据虽然读入了缓存，却没有及时用上，而缓存的大小是有限的，等执行到第九次内循环时
缓存的第一行数据已经被新的数据 [8,0]...[8,13][8,0]...[8,13] 覆盖掉了，以后如果再想读，比如 [0,1][0,1]，又得到内存去读了
同理可以分析 ij 函数则能充分利用局部性原理加载到的缓存数据
举一反三
-
I/O 读写时同样可以体现局部性原理
-
数组可以充分利用局部性原理，那么链表呢？
答：链表不行，因为链表的元素并非相邻存储
5) 越界检查
java 中对数组元素的读写都有越界检查，类似于下面的代码
bool is_within_bounds(int index) const
{
return 0 <= index && index < length();
}
- 代码位置：
openjdk\src\hotspot\share\oops\arrayOop.hpp
只不过此检查代码，不需要由程序员自己来调用，JVM 会帮我们调用
习题
E01. 合并有序数组 - 对应 Leetcode 88
将数组内两个区间内的有序元素合并
例
[1, 5, 6, 2, 4, 10, 11]
可以视作两个有序区间
[1, 5, 6] 和 [2, 4, 10, 11]
合并后，结果仍存储于原有空间
[1, 2, 4, 5, 6, 10, 11]
方法1
递归
- 每次递归把更小的元素复制到结果数组
merge(left=[1,5,6],right=[2,4,10,11],a2=[]){
merge(left=[5,6],right=[2,4,10,11],a2=[1]){
merge(left=[5,6],right=[4,10,11],a2=[1,2]){
merge(left=[5,6],right=[10,11],a2=[1,2,4]){
merge(left=[6],right=[10,11],a2=[1,2,4,5]){
merge(left=[],right=[10,11],a2=[1,2,4,5,6]){
// 拷贝10，11
}
}
}
}
}
}
代码
public static void merge(int[] a1, int i, int iEnd, int j, int jEnd,
int[] a2, int k) {
if (i > iEnd) {
System.arraycopy(a1, j, a2, k, jEnd - j + 1);
return;
}
if (j > jEnd) {
System.arraycopy(a1, i, a2, k, iEnd - i + 1);
return;
}
if (a1[i] < a1[j]) {
a2[k] = a1[i];
merge(a1, i + 1, iEnd, j, jEnd, a2, k + 1);
} else {
a2[k] = a1[j];
merge(a1, i, iEnd, j + 1, jEnd, a2, k + 1);
}
}
测试
int[] a1 = {1, 5, 6, 2, 4, 10, 11};
int[] a2 = new int[a1.length];
merge(a1, 0, 2, 3, 6, a2, 0);
方法2
代码
public static void merge(int[] a1, int i, int iEnd,
int j, int jEnd,
int[] a2) {
int k = i;
while (i <= iEnd && j <= jEnd) {
if (a1[i] < a1[j]) {
a2[k] = a1[i];
i++;
} else {
a2[k] = a1[j];
j++;
}
k++;
}
if (i > iEnd) {
System.arraycopy(a1, j, a2, k, jEnd - j + 1);
}
if (j > jEnd) {
System.arraycopy(a1, i, a2, k, iEnd - i + 1);
}
}
测试
int[] a1 = {1, 5, 6, 2, 4, 10, 11};
int[] a2 = new int[a3.length];
merge(a1, 0, 2, 3, 6, a2);结束啦，希望大家能有所成！！！
你好,我是胡广。 致力于为帮助兄弟们的学习方式、面试困难、入职经验少走弯路而写博客 🌹🌹🌹 坚持每天两篇高质量文章输出，加油！！！🤩
如果本篇文章帮到了你 不妨点个赞吧~ 我会很高兴的 😄 (^ ~ ^) 。想看更多 那就点个关注 吧 我会尽力带来有趣的内容 。
😎感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以 给我留言咨询，希望帮助更多的人
更多专栏:
📊 Java设计模式宝典：从入门到精通（持续更新）☔️ 未完待续。。。
🐽 未完待续。。。
⚡️ 未完待续。。。
🌗 未完待续。。。
感谢订阅专栏 三连文章
扫一扫
551
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
