1. 数据结构的存储方式

数据结构的存储方式只有两种：数组(顺序存储)和链表(链式存储)。
对于数据结构，我们知道许多，比如数组、链表、栈、队列、树、堆、图和散列表。但是呢？这些数据结构的本质都是数组和链表。上面的数据结构都是上层建筑，而数组和链表是这些数据结构的基础。如何理解呢？这么多样化的数据结构，究其源头，都是在链表或者数组上的特殊操作，API不同而已。
栈、队列：这两种数据结构既可以使用链表也可以使用数组实现。用数组实现，就要处理扩容收缩的问题；用链表实现，没有扩容收缩问题，但需要更多的内存空间存储节点指针。
树：用数组实现就是**堆，因为堆是一个完全二叉树，用数组存储不需要节点指针，操作也比较简单；用链表实现就是很常见的**树，因为不一定是完全二叉树，所以不适合用数组存储。为此，在这种链表树结构之上，又衍生出各种巧妙的设计，比如二叉搜索树、AVL树、红黑树、区间树、B树等等，以应对不同的问题。
图：图有两种标识方法，邻接表就是链表，邻接矩阵就是二维数组。邻接矩阵判断连通性信息，并可以进行矩阵运算解决一些问题，但是如果图比较稀疏的话很耗费空间。邻接表比较节省空间，但是很多操作的效率上肯定比不过邻接矩阵。
散列表：散列表是通过散列函数将键映射到一个数组里。而且对于解决散列冲突的方法，拉链法需要链表特性，操作简单，但需要额外的空间存储指针；线性探查法就需要数组特性，以便连续寻址，不需要指针的存储空间，但操作稍微复杂些。

数据结构种类很多，甚至你也可以发明自己的数据结构，但是底层存储无非数组或者链表，二者的优缺点如下：
数组**：由于是紧凑连续存储,可以随机访问，通过索引快速找到对应元素，而且相对节约存储空间。但正因为连续存储，内存空间必须一次性分配够，所以说数组如果要扩容，需要重新分配一块更大的空间，再把数据全部复制过去，时间复杂度 O(N)；而且你如果想在数组中间进行插入和删除，每次必须搬移后面的所有数据以保持连续，时间复杂度 O(N)。
链表**：因为元素不连续，而是靠指针指向下一个元素的位置，所以不存在数组的扩容问题；如果知道某一元素的前驱和后驱，操作指针即可删除该元素或者插入新元素，时间复杂度 O(1)。但是正因为存储空间不连续，你无法根据一个索引算出对应元素的地址，所以不能随机访问；而且由于每个元素必须存储指向前后元素位置的指针，会消耗相对更多的储存空间。

2. 数据结构的基本操作

对于任何数据结构，其基本操作无非遍历+访问，再具体一点就是：增删改查。
数据结构种类很多，但它们存在的目的就是在不同的引用场景，尽可能高效地增删改查。话说这不就是数据结构的使命么？
如何遍历+访问？我们仍然从最高层来看，任何数据结构的遍历+访问无非两种形式：线性的和非线性的。线性就是for/while迭代为代表，非线性就是递归为代表。再具体一步：无非以下框架：

数组遍历框架，典型的线性迭代结构：

void traverse(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        // 迭代访问arr[i]
    }
}

链表遍历框架，兼具迭代和递归结构：

/* 基本的单链表节点 */
class ListNode {
    int val;
    ListNode next;
}
// 线性遍历+访问
void traverse(ListNode head) {
    for (ListNode p = head; p != null; p = p.next) {
        // 迭代访问p.val
    }
}
// 递归迭代+访问
void traverse(ListNode head) {
    // base case;
    // 递归访问head.val
    traverse(head.next);
}

二叉树遍历框架，典型的非线性递归遍历：

/* 基本的二叉树节点 */
class TreeNode {
    int val;
    TreeNode left, right;
}
void traverse(TreeNode root) {
    // base case;
    // 递归访问root.val
    traverse(root.left);
    traverse(root.right);
}

你看二叉树的递归遍历方式和链表的递归遍历方式，相似不？再看看二叉树结构和单链表结构，相似不？如果再多几条叉，N 叉树你会不会遍历？

二叉树框架可以扩展为N叉树的遍历框架：

/* 基本的N叉树节点 */
class TreeNode {
    int val;
    TreeNode[] children;
}
void traverse(TreeNode root) {
    for (TreeNode chile : root.children) {
        traverse(child);
    }
}

N 叉树的遍历又可以扩展为图的遍历，因为图就是好几 N 叉棵树的结合体。你说图是可能出现环的？这个很好办，用个布尔数组 visited 做标记就行了。

图的遍历：暂略。

所谓框架，就是套路。不管增删查改，这些代码都是永远无法脱离的结构，你可以把这个结构作为大纲，根据具体问题在框架上添加代码就行了，下面会具体举例。

3. 算法刷题指南

首先要明确的是，数据结构是工具，算法是通过合适的工具解决特定问题的方法。也就是说，学习算法之前，最起码得了解那些常用的数据结构，了解它们的特性和缺陷。
先刷二叉树、先刷二叉树、先刷二叉树！
大部分人可能觉得动态规范、DFS、BFS等更需要关注。我们为什么要先刷二叉树呢？因为二叉树是最容易培养框架思维的，而且大部分算法技巧，本质上都是树的遍历问题。
刷二叉树看到题目没思路？根据很多读者的问题，其实大家不是没思路，只是没有理解我们说的「框架」是什么。不要小看这几行破代码，几乎所有二叉树的题目都是一套这个框架就出来了。

void tarverse(TreeNode root) {
    // 前序遍历
    traverse(root.left);
    // 中序遍历
    traverse(root.right);
    // 后序遍历
}

比如说我随便拿几道题的解法出来，不用管具体的代码逻辑，只要看看框架在其中是如何发挥作用的就行。

LeetCode 124

求二叉树中最大路径和
不会
看出了吗？着就是个后序遍历嘛。

LeetCode 105

根据一棵树的前序遍历与中序遍历构造二叉树。
不会
不要看这个函数的参数很多，只是为了控制数组索引而已，本质上该算法也就是一个前序遍历。
后面略。。。。。。
刷完整个专题，再去做什么回溯动规分治专题，你就会发现只要涉及递归的问题，都是树的问题。
再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。
综上，对于算法无从下手的朋友来说，可以先刷树的相关题目，试着从框架上看问题，而不要纠结于细节问题。
纠结细节问题，就比如纠结 i 到底应该加到 n 还是加到 n - 1，这个数组的大小到底应该开 n 还是 n + 1 ？
从框架上看问题，就是像我们这样基于框架进行抽取和扩展，既可以在看别人解法时快速理解核心逻辑，也有助于找到我们自己写解法时的思路方向。
当然，如果细节出错，你得不到正确的答案，但是只要有框架，你再错也错不到哪去，因为你的方向是对的。
但是，你要是心中没有框架，那么你根本无法解题，给了你答案，你也不会发现这就是个树的遍历问题。
这种思维是很重要的，动态规划详解中总结的找状态转移方程的几步流程，有时候按照流程写出解法，说实话我自己都不知道为啥是对的，反正它就是对了。。。
这就是框架的力量，能够保证你在快睡着的时候，依然能写出正确的程序；就算你啥都不会，都能比别人高一个级别。

最后总结

数据结构的基本存储方式就是链式和顺序两种，基本操作就是增删查改，遍历方式无非迭代和递归。
刷算法题建议从「树」分类开始刷，结合框架思维，把这几十道题刷完，对于树结构的理解应该就到位了。这时候去看回溯、动规、分治等算法专题，对思路的理解可能会更加深刻一些。
最后，除了树的问题，还有一些其他类型问题的框架套路，我都有总结过，在下面简单列一下
略

数据结构与算法(LeetCode)