第0篇：学习数据结构和算法的框架思维

àì夳堔傛蜴生んèń 2022-12-31 02:18 32阅读 0赞

## 学习数据结构和算法的框架思维 ##

**⼀、数据结构的存储⽅式：**

**数据结构的存储⽅式只有两种：数组（顺序存储）和链表（链式存储）。**

这句话怎么理解，不是还有散列表、栈、队列、堆、树、图等等各种数据结 构吗？

我们分析问题，⼀定要有递归的思想，⾃顶向下，从抽象到具体。你上来就 列出这么多，那些都属于「上层建筑」，⽽数组和链表才是「结构基础」。 因为那些多样化的数据结构，究其源头，都是在链表或者数组上的特殊操 作，API 不同⽽已。

⽐如说：**「队列**」、「**栈**」这两种数据结构既可以使⽤链表也可以使⽤数组实 现。⽤数组实现，就要处理扩容缩容的问题；⽤链表实现，没有这个问题， 但需要更多的内存空间存储节点指针。

「**图**」的两种表⽰⽅法，邻接表就是链表，邻接矩阵就是⼆维数组。邻接矩 阵判断连通性迅速，并可以进⾏矩阵运算解决⼀些问题，但是如果图⽐较稀 疏的话很耗费空间。邻接表⽐较节省空间，但是很多操作的效率上肯定⽐不 过邻接矩阵。

「**散列表**」就是通过散列函数把键映射到⼀个⼤数组⾥。⽽且对于解决散列 冲突的⽅法，拉链法需要链表特性，操作简单，但需要额外的空间存储指 针；线性探查法就需要数组特性，以便连续寻址，不需要指针的存储空间， 但操作稍微复杂些。

「**树**」，⽤数组实现就是「堆」，因为「堆」是⼀个完全⼆叉树，⽤数组存 储不需要节点指针，操作也⽐较简单；⽤链表实现就是很常⻅的那种 「树」，因为不⼀定是完全⼆叉树，所以不适合⽤数组存储。为此，在这种 链表「树」结构之上，⼜衍⽣出各种巧妙的设计，⽐如⼆叉搜索树、AVL 树、红⿊树、区间树、B 树等等，以应对不同的问题。

了解 **Redis 数据库**的朋友可能也知道，Redis 提供列表、字符串、集合等等 ⼏种常⽤数据结构，但是对于每种数据结构，底层的存储⽅式都⾄少有两 种，以便于根据存储数据的实际情况使⽤合适的存储⽅式。

综上，数据结构种类很多，甚⾄你也可以发明⾃⼰的数据结构，但是底层存 储⽆⾮数组或者链表，**⼆者的优缺点如下：**

\*\*数组\*\*由于是紧凑连续存储,可以随机访问，通过索引快速找到对应元素，⽽ 且相对节约存储空间。但正因为连续存储，内存空间必须⼀次性分配够，所 以说数组如果要扩容，需要重新分配⼀块更⼤的空间，再把数据全部复制过 去，时间复杂度 O(N)；⽽且你如果想在数组中间进⾏插⼊和删除，每次必 须搬移后⾯的所有数据以保持连续，时间复杂度 O(N)。

\*\*链表\*\*因为元素不连续，⽽是靠指针指向下⼀个元素的位置，所以不存在数组 的扩容问题；如果知道某⼀元素的前驱和后驱，操作指针即可删除该元素或 者插⼊新元素，时间复杂度 O(1)。但是正因为存储空间不连续，你⽆法根 据⼀个索引算出对应元素的地址，所以不能随机访问；⽽且由于每个元素必 须存储指向前后元素位置的指针，会消耗相对更多的储存空间。

**⼆、数据结构的基本操作：**

对于任何数据结构，其基本操作⽆⾮遍历 + 访问，再具体⼀点就是：增删 查改。

**数据结构种类很多，但它们存在的⽬的都是在不同的应⽤场景，尽可能⾼效 地增删查改**。话说这不就是数据结构的使命么？

如何遍历 + 访问？我们仍然从最⾼层来看，各种数据结构的遍历 + 访问⽆ ⾮两种形式：线性的和⾮线性的。

线性就是 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) 
    {
         
    	// 递归访问 head.val traverse(head.next)
    }

⼆叉树遍历框架，典型的⾮线性递归遍历结构：

/* 基本的⼆叉树节点 */ 
    class TreeNode 
    {
         
    	int val; 
    	TreeNode left, right; 
    }
    
    void traverse(TreeNode root) 
    {
         
    	traverse(root.left) 
    	traverse(root.right) 
    }

你看⼆叉树的递归遍历⽅式和链表的递归遍历⽅式，相似不？再看看⼆叉树 结构和单链表结构，相似不？如果再多⼏条叉，N 叉树你会不会遍历？  
⼆叉树框架可以扩展为 N 叉树的遍历框架：

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

N 叉树的遍历⼜可以扩展为图的遍历，因为图就是好⼏ N 叉棵树的结合 体。你说图是可能出现环的？这个很好办，⽤个布尔数组 visited 做标记就 ⾏了，这⾥就不写代码了。

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

**三、算法刷题指南：**

⾸先要明确的是，**数据结构是⼯具，算法是通过合适的⼯具解决特定问题的方法**。也就是说，学习算法之前，最起码得了解那些常⽤的数据结构，了解 它们的特性和缺陷。

那么该如何在 LeetCode 刷题呢？  
直接说具体的建议：

**先刷⼆叉树，先刷⼆叉树，先刷⼆叉树！**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70]  
⼤部分⼈对数据结构相关的算法⽂章不感兴趣，⽽是更关⼼动规回溯分治等等技巧。  
为什么要先刷⼆叉树呢？  
**因为⼆叉树是最容易培养框架思维的，⽽且⼤部分算法技巧，本质上都是树的遍历题。**

刷⼆叉树看到题⽬没思路？

其实⼤家不是没思路，只是没有理解我们说的「框架」是什么。不要⼩看这⼏⾏破代码，⼏乎所有⼆ 叉树的题⽬都是⼀套这个框架就出来了。

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

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

LeetCode 124 题，**难度 Hard**，让你求⼆叉树中最⼤路径和，主要代码如下：

int ans = INT_MIN; 
    int oneSideMax(TreeNode* root) 
    {
         
    	if (root == nullptr) 
    		return 0; 
    	int left = max(0, oneSideMax(root->left)); 
    	int right = max(0, oneSideMax(root->right)); 
    	ans = max(ans, left + right + root->val); 
    	return max(left, right) + root->val; 
    }

你看，这就是个后序遍历嘛。

LeetCode 105 题，**难度 Medium**，让你根据前序遍历和中序遍历的结果还原 ⼀棵⼆叉树，很经典的问题吧，主要代码如下：

TreeNode buildTree(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd, Map<Integer, Integer> inMa p) 
    {
        
    	if(preStart > preEnd || inStart > inEnd) 
    	    return null; 
    	    TreeNode root = new TreeNode(preorder[preStart]); 
    	    int inRoot = inMap.get(root.val); 
    	    int numsLeft = inRoot - inStart;
    
    		root.left = buildTree(preorder, preStart + 1, preStart + numsLeft , inorder, inStart, inRoot - 1, inMap); 
    		root.right = buildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd, inMap); 
    		return root; 
    }

不要看这个函数的参数很多，只是为了控制数组索引⽽已，本质上该算法也 就是⼀个前序遍历。

LeetCode 99 题，**难度 Hard**，恢复⼀棵 BST，主要代码如下：

void traverse(TreeNode* node) 
    {
         
    	if (!node) 
    		return; 
    	traverse(node->left);
     	if (node->val < prev->val)
     	{
         
     		s = (s == NULL) ? prev : s; 
     		t = node; 
     	}
     	prev = node; 
     	traverse(node->right); 
    }

这不就是个中序遍历嘛，对于⼀棵 BST 中序遍历意味着什么，应该不需要 解释了吧。

你看，Hard 难度的题⽬不过如此，⽽且还这么有规律可循，只要把框架写 出来，然后往相应的位置加东⻄就⾏了，这不就是思路嘛。

对于⼀个理解⼆叉树的⼈来说，刷⼀道⼆叉树的题⽬花不了多⻓时间。那么 如果你对刷题⽆从下⼿或者有畏惧⼼理，不妨从⼆叉树下⼿，前 10 道也许 有点难受；结合框架再做 20 道，也许你就有点⾃⼰的理解了；刷完整个专 题，再去做什么回溯动规分治专题，**你就会发现只要涉及递归的问题，都是 树的问题。**

再举例吧，动态规划详解说过凑零钱问题，暴⼒解法就是遍历⼀棵 N 叉树：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 1]

def coinChange(coins: List[int], amount: int):
    
    def dp(n): 
    	if n == 0: return 0 
    	if n < 0: return -1 
    
    	res = float('INF') 
    	for coin in coins:
    		subproblem = dp(n - coin) 
    		//⼦问题⽆解，跳过 
    		if subproblem == -1: continue 
    		res = min(res, 1 + subproblem) 
    	return res 
    	if res != float('INF') 
    	else -1 
    
    return dp(amount)

这么多代码看不懂咋办？直接提取出框架，就能看出核⼼思路了：

# 不过是⼀个 N 叉树的遍历问题⽽已 
    def dp(n): 
    	for coin in coins: 
    		dp(n - coin)

其实很多动态规划问题就是在遍历⼀棵树，你如果对树的遍历操作烂熟于⼼，起码知道怎么把思路转化成代码，也知道如何提取别⼈解法的核⼼思路。

再看看回溯算法，前⽂回溯算法详解⼲脆直接说了，回溯算法就是个 N 叉 树的前后序遍历问题，没有例外。

⽐如 N 皇后问题吧，主要代码如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 2]

void backtrack(int[] nums, LinkedList<Integer> track) 
    {
         
    	if (track.size() == nums.length) 
    	{
         
    		res.add(new LinkedList(track)); 
    		return; 
    	}
    }
    
    for (int i = 0; i < nums.length; i++) 
    {
         
    	if (track.contains(nums[i])) 
    		continue; 
    	track.add(nums[i]); 
    	// 进⼊下⼀层决策树 
    	backtrack(nums, track); 
    	track.removeLast(); 
    } 
    /* 提取出 N 叉树遍历框架 */ 
    void backtrack(int[] nums, LinkedList<Integer> track) 
    {
         
    	for (int i = 0; i < nums.length; i++) 
    	{
         
    		backtrack(nums, track); 
    	}
    }

N 叉树的遍历框架，找出来了把〜你说，树这种结构重不重要？

**综上，对于畏惧算法的朋友来说，可以先刷树的相关题⽬，试着从框架上看 问题，⽽不要纠结于细节问题。**

纠结细节问题，就⽐如纠结 i 到底应该加到 n 还是加到 n - 1，这个数组的⼤ ⼩到底应该开 n 还是 n + 1 ？

从框架上看问题，就是像我们这样基于框架进⾏抽取和扩展，既可以在看别 ⼈解法时快速理解核⼼逻辑，也有助于找到我们⾃⼰写解法时的思路⽅向。

当然，如果细节出错，你得不到正确的答案，但是只要有框架，你再错也错 不到哪去，因为你的⽅向是对的。

但是，你要是⼼中没有框架，那么你根本⽆法解题，给了你答案，你也不会 发现这就是个树的遍历问题。

这种思维是很重要的，动态规划详解中总结的找状态转移⽅程的⼏步流程， 有时候按照流程写出解法，说实话我⾃⼰都不知道为啥是对的，反正它就是 对了。。。

**这就是框架的⼒量，能够保证你在快睡着的时候，依然能写出正确的程序； 就算你啥都不会，都能⽐别⼈⾼⼀个级别。**

**四、总结几句：**

数据结构的基本存储⽅式就是链式和顺序两种，基本操作就是增删查改，遍 历⽅式⽆⾮迭代和递归。

刷算法题建议从「树」分类开始刷，结合框架思维，把这⼏⼗道题刷完，对 于树结构的理解应该就到位了。这时候去看回溯、动规、分治等算法专题， 对思路的理解可能会更加深刻⼀些。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70]: /images/20221120/63d66ec3dfcb4ce1b41faefed8d645c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 1]: /images/20221120/2d8e761e74aa4ae29726931926cb978c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 2]: /images/20221120/6d58c0c4909c4856a900443dc126c928.png