数据结构与算法

介绍

数据结构&算法的定义

数据结构就是指一组数据的存储结构。
算法就是操作数据的一组方法。
数据结构和算法，是指某些著名的队列、栈、堆、二分查找、动态规划等。

数据结构和算法的关系

数据结构和算法是相辅相成的。
数据结构是为算法服务的，算法要作用在特定的数据结构之上。
因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构。


比如，因为数组具有随机访问的特点，常用的二分查找算法需要用数组来存储数据。但如果我们选择链表这种数据结构，二分查找算法就无法工作了，因为链表并不支持随机访问。

数据结构是静态的，它只是组织数据的一种方式。如果不在它的基础上操作、构建算法，孤立存在的数据结构就是没用的。

数据结构与算法整体知识

20 个最常用的、最基础数据结构与算法：
10 个数据结构：数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Trie 树；
10 个算法：递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。

线性表

线性表与非线性表

线性表（Linear List），就是数据排成像一条线一样的结构。每个线性表上的数据最多只有前和后两个方向，包括数组，链表、队列、栈等。

非线性表，数据之间并不是简单的前后关系，有二叉树、图等，如下图：

数组

数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。

数组是一种最基础的数据结构，在大部分编程语言中，数组都是从 0 开始编号的。

数组实现随机访问的方法

数组使用了连续的内存空间和相同类型的数据。使得它可以“随机访问”，但同时也让数组的删除、插入等操作变得非常低效，为了保证连续性，就需要做大量的数据搬移工作。

数组的低效操作

插入操作

	假设数组 a[10] 中存储了如下 5 个元素：a，b，c，d，e。
	现在需要将元素 x 插入到第 3 个位置。我们只需要将 c 放入到 a[5]，将 a[2] 赋值为 x 即可：

删除操作

如果我们要删除第 k 个位置的数据，为了内存的连续性，也需要搬移数据，不然中间就会出现空洞，内存就不连续了。

如果删除数组末尾的数据，则最好；如果删除开头的数据，则最坏；

实际上，在某些特殊场景下，我们并不一定非得追求数组中数据的连续性。可以将多次删除操作集中在一起执行。

比如数组 a[10] 中存储了 8 个元素：a，b，c，d，e，f，g，h。要依次删除 a，b，c 三个元素：

为了避免 d，e，f，g，h 这几个数据会被搬移三次，可以先记录下已经删除的数据。每次的删除操作并不是真正地搬移数据，只是记录数据已经被删除。当数组没有更多空间存储数据时，再触发执行一次真正的删除操作。

这有点像是Python中的标记清除垃圾回收算法的核心思想

警惕数组的访问越界问题

#include<stdio.h>

int main(int argc, char* argv[]){
    int i = 0;
    int arr[] = {11, 22, 33};

    for(; i<=3; i++){
        printf("i=%d, arr[%d]=%d\n", i, i, arr[i]);
    }
    return 0;
}



上段程序运行结果：

i=0, arr[0]=11
i=1, arr[1]=22
i=2, arr[2]=33
i=3, arr[3]=-1121713994



能否发现 i=3, arr[3]=-1121713994也执行了，但数组只有3个元素，而arr[3]实际上是第4个数据了

那这说明什么？

在 C 语言中，a[3] 被定位到某块不属于数组的内存地址上，其他高级语言一般会报下标越界异常。

访问数组的本质就是访问一段连续内存，在 C 语言中只要数组通过偏移计算得到的内存地址是可用的，那么程序就可能不会报任何错误。

C语言把数组越界检查的工作丢给程序员来做，但Python本身就会做越界检查，比如下面这几行Python代码，就会抛出异常

nums = [11, 22, 33]
num2[3] = 44  # 此时产生异常

为什么数组要从 0 开始编号?

为什么数组要从 0 开始编号，而不是从 1 开始呢？ 从 1 开始不是更符合人类的思维习惯吗？从数组存储的内存模型上来看，“下标”最确切的定义应该是“偏移（offset）”。


从 0 开始编号，数组 a[k] 的内存寻址公式为：
a[k]_address = base_address + k * type_size

从 1 开始编号，数组 a[k] 的内存寻址公式为：
a[k]_address = base_address + (k-1)*type_size

对比两个公式，从 1 开始编号，每次随机访问数组元素都多了一次减法运算，对于 CPU 来说，就是多了一次减法指令。


所以为了减少一次减法操作，数组选择了从 0 开始编号，而不是从 1 开始。另外，C 语言设计者用 0 开始计数数组下标，之后的Python、 Java、JavaScript 等高级语言都效仿了 C 语言，或者说，为了在一定程度上减少 C 语言程序员学习其他编程语言的学习成本，因此继续沿用了从 0 开始计数的习惯。	
当然，并不是所有语言的数组都是从 0 开始计数的，比如 Matlab

二维数组的内存寻址公式

对于 m * n 的数组，a[i][j] (i<m,j<n)​的地址为：
address = base_address + (i*n+j)*type_size

链表概念

1. 空间换时间&时间换空间

空间换时间的设计思想：当内存空间充足的时候，为了追求代码更快的执行速度，就可以舍弃对存储空间的要求，从而追求效率
时间换空间的设计思想：内存空间比较紧缺时，为了让程序稳定运行，就需要舍弃时间，极大满足对存储空间的要求。


缓存实际上就是利用了空间换时间的设计思想。如果我们把数据存储在硬盘上，会比较节省内存，但每次查找数据都要询问一次硬盘，会比较慢。但如果我们通过缓存技术，事先将数据加载在内存中，虽然会比较耗费内存空间，但是每次数据查询的速度就大大提高了。

总结:
对于执行较慢的程序，可以通过消耗更多的内存（空间换时间）来进行优化；
对于内存消耗过多的程序，可以通过消耗更多的时间（时间换空间）来降低内存的消耗。

2.链表的存储结构

数组需要一块连续的内存空间来存储，需要事先申请需要申请内存空间；而链表通过“指针”将一组零散的内存块串联起来使用，不会占用还未使用的内存空间。

3.最常见的链表结构
单链表

链表通过指针将一组零散的内存块串联在一起，内存块称为链表的“结点”。每个链表的结点除了存储数据之外，还需要记录链上的下一个结点的地址，叫作后继指针 next。

上图中有两个特殊的结点，分别是第一个结点（头结点）和最后一个结点（尾结点）。
头结点用来记录链表的基地址，用它可以遍历得到整条链表。
尾结点指向一个空地址 NULL，表示这是链表上最后一个结点。

循环链表

循环链表跟单链表的区在尾结点指针是指向链表的头结点。

和单链表相比，循环链表的优点是从链尾到链头比较方便。
当要处理的数据具有环型结构特点时，采用循环链表实现代码会简洁很多。

双向链表

双向链表支持两个方向，每个结点同时有后继指针 next 指向后面的结点，还有一个前驱指针 prev 指向前面的结点。

双向链表需要额外的两个空间来存储后继结点和前驱结点的地址，存储同样的数据，双向链表要比单链表占用更多的内存空间。

链表操作

1.三种基本操作

删除操作

插入操作

查询操作

链表的随机访问第 k 个元素，必须根据指针一个结点一个结点地依次遍历，直到找到相应的结点。

对于一个有序链表，双向链表的按值查询的效率会比单链表高一些。记录上次查找的位置 p，每次查询时，根据要查找的值与 p 的大小关系，决定是往前还是往后查找，双向链表平均只需要查找一半的数据。

链表 VS 数组性能大比拼

1.数组简单易用，在实现上使用的是连续的内存空间，可以借助 CPU 的缓存机制，预读数组中的数据，所以访问效率更高
2.而链表在内存中并不是连续存储，所以对 CPU 缓存不友好，没办法有效预读。
3.数组的缺点是大小固定，一经声明就要占用整块连续内存空间。如果声明的数组过大，系统可能没有足够的连续内存空间分配给它，导致“内存不足(out of memory)”。如果声明的数组过小，则可能出现不够用的情况。这时只能再申请一个更大的内存空间，把原数组拷贝进去，非常费时。
4.链表本身没有大小的限制，天然地支持动态扩容。
5.如果对内存的使用非常苛刻数组就更适合，因为链表中的每个结点都需要消耗额外的存储空间去存储一份指向下一个结点的指针，所以内存消耗会翻倍。
6.对链表进行频繁的插入、删除操作，会导致频繁的内存申请和释放，容易造成内存碎片，对于Python编程语言，就有可能会导致频繁的 GC（Garbage Collection，垃圾回收）。

链表应用-LRU 缓存

缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的 CPU 缓存、数据库缓存、浏览器缓存等等。

常见的缓存淘汰策略

先进先出策略 FIFO（First In，First Out）
最少使用策略 LFU（Least Frequently Used）
最近最少使用策略 LRU（Least Recently Used）

LRU缓存的实现

思路：
维护一个有序单链表，越靠近链表尾部的结点是越早之前访问的。当有一个新的数据被访问时，从链表头开始顺序遍历链表：

如果此数据之前已经被缓存在链表中了，遍历得到这个数据对应的结点，并将其从原来的位置删除，然后再插入到链表的头部。

如果此数据没有在缓存链表中,，则将此结点插入到链表的头部；

如果此时缓存超过容量，则链表尾结点删除。

链表逆序

什么是逆序
就是首变尾 尾变首