精华内容
下载资源
问答
  • 数据结构中的线性结构也就是“线性表”逻辑结构,现在可以肯定队列存储结构,队列线性表,顺序链表也线性表,一维数组和顺序表又基本上一回事,那么顺序链表也是存储结构吗?...
  • 数据结构的存储⽅式只有两种:数组(顺序存储链表(链式存储)。 这句话怎么理解,不是还有散列表、队列、堆、树、图等等各种数据结 构吗? 我们分析问题,⼀定要有递归的思想,⾃顶向下,从抽象到具体。你...

    一、数组和链表

    数据结构的存储⽅式只有两种:数组(顺序存储)和链表(链式存储)。
    这句话怎么理解,不是还有散列表、栈、队列、堆、树、图等等各种数据结 构吗? 我们分析问题,⼀定要有递归的思想,⾃顶向下,从抽象到具体。你上来就 列出这么多,那些都属于「上层建筑」,⽽数组和链表才是「结构基础」。 因为那些多样化的数据结构,究其源头,都是在链表或者数组上的特殊操 作,API 不同⽽已。

    1、队列和栈

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

    2、图

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

    3、散列表

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

    4、树

    「树」,⽤数组实现就是「堆」,因为「堆」是⼀个完全⼆叉树,⽤数组存 储不需要节点指针,操作也⽐较简单;⽤链表实现就是很常⻅的那种 「树」,因为不⼀定是完全⼆叉树,所以不适合⽤数组存储。为此,在这种 链表「树」结构之上,⼜衍⽣出各种巧妙的设计,⽐如⼆叉搜索树、AVL 树、红⿊树、区间树、B 树等等,以应对不同的问题。 了解 Redis 数据库的朋友可能也知道,Redis 提供列表、字符串、集合等等 ⼏种常⽤数据结构,但是对于每种数据结构,底层的存储⽅式都⾄少有两 种,以便于根据存储数据的实际情况使⽤合适的存储⽅式。

    点击这里可以获取Java数据结构和算法视频教程AI算法工程师视频学习课程。
    数据结构和算法视频教程

    二、数组和链表的优缺点

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

    数组由于是紧凑连续存储,可以随机访问,通过索引快速找到对应元素,⽽ 且相对节约存储空间。但正因为连续存储,内存空间必须⼀次性分配够,所 以说数组如果要扩容,需要重新分配⼀块更⼤的空间,再把数据全部复制过 去,时间复杂度 O(N);

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

    展开全文
  • 数据结构的存储⽅式只有两种:数组(顺序存储链表(链式存储)。 这句话怎么理解,不是还有散列表、队列、堆、树、图等等各种数据结 构吗? 我们分析问题,⼀定要有递归的思想,⾃顶向下,从抽象到具体。你...

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

    ⼀、数据结构的存储⽅式:

    数据结构的存储⽅式只有两种:数组(顺序存储)和链表(链式存储)。

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

    我们分析问题,⼀定要有递归的思想,⾃顶向下,从抽象到具体。你上来就 列出这么多,那些都属于「上层建筑」,⽽数组和链表才是「结构基础」。 因为那些多样化的数据结构,究其源头,都是在链表或者数组上的特殊操 作,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 刷题呢?
    直接说具体的建议:

    先刷⼆叉树,先刷⼆叉树,先刷⼆叉树!

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

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

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

    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 叉树:
    在这里插入图片描述

    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 皇后问题吧,主要代码如下:
    在这里插入图片描述

    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 ?

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

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

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

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

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

    四、总结几句:

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

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

    展开全文
  • 数据结构总结

    2017-12-14 21:15:45
    数据结构的开头,向我们讲解了什么数据结构吗,算是对于数据结构一次定义。...后面的一系列数据结构的存储结构,都被分为了顺序存储结构和链式存储结构。  这个学期,在数据结构的学习中,我学到了

            数据结构的开头,是向我们讲解了什么是数据结构吗,算是对于数据结构一次定义。接下来又介绍了算法,最后在第一章的结尾,定义了程序的概念。从第二章开始,就开始讲解线性表,栈,队列等一系列的数据结构。同时,按照第一章所认识的顺序,一次讲解他们各自的逻辑结构和存储结构以及代码和应用。后面的一系列数据结构的存储结构,都被分为了顺序存储结构和链式存储结构。

           这个学期,在数据结构的学习中,我学到了新的学习方法。通过观看老师课前录制的视频,提前一步进行预习,这样在课堂上就可以进行更快速的学习。而且,如果某些章节的掌握不够好,还可以通过观看视频进行复习巩固。而且,贺老师对于这门课程非常注重实践能力。所以十分看重上级课,在上机课中我学到如何建立C++工程,老师说这是以后做很多事情的基础。而且老师给我介绍了一个新的学习平台,CSDN博客。通过博客可以发表自己的编程或在博客上观看他人的博客进行学习。

           这个学期的数据结构学习,贺老湿带给我们的是全新的学习方式,这是一种相对于传统学习方式完全不同的学习方式。任何事物无法从绝对上来评价对错。但单从个人观点来看,我觉得这种学习方式很不错,毕竟这是大学。而且这种学习方式可以让我随时学习,正如我前面所说的,有时某些知识点不会了,就可以打开相应章节的视频看一下,真的非常有用。一开始时,我很不适应,总觉得知识还是上课学比较好,但是慢慢适应后,还是觉得这种学习方法更加自由高效。

           课程也快到最后了,到了要准备考试的时候了。正如老师那次跟我所说的一样,你不能再想之前那样了慢了,要有明确的计划,因为时间已经不够我浪费了,要稍微功利一下了。我决定最后时间抓紧一下,在不耽误别的学科复习的情况下,先完成老师布置的每周实践,再进行课本知识的复习,争取通过考试。

    展开全文
  • 大话数据结构

    2018-12-14 16:02:18
    4.4.2顺序存储结构进栈操作 93 4.4.3顺序存储结构出栈操作 94 4.5两共享空间 94 两个大学室友毕业同时到北京工作,他们都希望租房时能找到独自住的一室户或一室一厅,可找来找去发现,实在承受不起。 ...
  • 数据结构的存储⽅式只有两种:数组(顺序存储链表(链式存储)。 这句话怎么理解,不是还有散列表、队列、堆、树、图等等各种数据结 构吗? 我们分析问题,⼀定要有递归的思想,⾃顶向下,从抽象到具体。...

    ⼀、数据结构的存储⽅式

    数据结构的存储⽅式只有两种:数组(顺序存储)和链表(链式存储)。

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

    我们分析问题,⼀定要有递归的思想,⾃顶向下,从抽象到具体。你上来就 列出这么多,那些都属于「上层建筑」,⽽数组和链表才是「结构基础」。
    因为那些多样化的数据结构,究其源头,都是在链表或者数组上的特殊操 作,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 做标记就 ⾏了,这⾥就不写代码了。

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

    转自:《labuladong的算法小抄》
    自己做了简单排版
    这个应该是他文章的链接:数据结构和算法学习的框架思维

    展开全文
  • 我们知道符合条件的数据结构就有队列和其它。 <p><strong>2.非线性结构其逻辑特征一个节点元素可以有多个直接前驱或多个直接后继。 那么,符合条件的数据结构就有图、树其它。 嗯~了解一下就行...
  • 数据结构 -- 数组 概念 数组一种线性表数据的结构,他用一组连续的...像队列,链表,线性表结构。对应的还有非线性表结构(数据没有先后顺序的,二叉树,堆等) 连续内存空间:计算机在分配内存空的时候都...
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    10. 在顺序存储结构中,有时也存储数据结构中元素之间的关系。( )【华南理工大学 2002 一、2 (1分)】 11. 顺序存储方式的优点存储密度大,且插入、删除运算效率高。( )【上海海运学院 1999 一、1(1分)】 12....
  • 算法 概述

    2020-07-02 10:27:36
    这句话怎么理解,不是还有散列表、队列、堆、树、图等等各种数据结构吗? 我们分析问题,一定要有递归的思想,自顶向下,从抽象到具体。你上来就列出这么多,那些都属于「上层建筑」,而数组链表才「结构...
  • A、队列 B、线性表 C、二叉树 D、 我的答案:C 2、 在结构化方法中,用数据流程图(DFD)作为描述工具的软件开发阶段()。 A、 可行性分析 B、需求分析 C、详细设计 D、程序编码 我的答案:B 3、 结构...
  • 集合类

    2015-07-15 22:39:29
    这些都很杂的东西,不是...线性表:一种常用的数据结构顺序存储 ,通过队列、字符串 拥有唯一的第一元素,唯一的最后元素。出最一个元素以外都已唯一的后继,出唯一的前继 有n个元素, 均匀性、有序性,顺
  • 第10课 栈和队列 10.1 栈 10.1.1 栈的基本定义 10.1.2 栈的常用操作 10.1.3 栈的顺序存储结构及实现 10.1.4 栈的链式存储结构及实现 10.1.5 Java集合中的栈 10.2 队列 10.2.1 队列的基本定义 10.2.2 队列...
  • 第10课 栈和队列 253 10.1 栈 254 10.1.1 栈的基本定义 254 10.1.2 栈的常用操作 254 10.1.3 栈的顺序存储结构及实现 255 10.1.4 栈的链式存储结构及实现 259 10.1.5 Java集合中的栈 263 10.2 队列 ...
  • 2.6.1 什么是队列结构 2.6.2 准备数据 2.6.3 初始化队列结构 2.6.4 判断空队列 2.6.5 判断满队列 2.6.6 清空队列 2.6.7 释放空间 2.6.8 入队列 2.6.9 出队列 2.6.10 读结点数据 2.6.11 计算队列长度 2.6.12 队列结构...
  • 10.4 栈和队列 面试题9:简述队列和栈的异同 面试题10:建立一个链式栈 面试题11:建立一个链式队列 面试题12:能否用两个栈实现一个队列的功能 10.5 二叉树 面试题13:建立一个二叉树 面试题14:计算一棵二叉树的...
  • 1.1.8 NFS SMB 最常见的两种 NAS(Network Attached Storage)协议,当把一个文件系统同时通过 NFS SMB 协议共享给多个主机访问时,以下哪些说法错误的 1.1.9 输入 ping IP 后敲回车,发包前会发生什么?...
  • 5.1.6 副作用和顺序点 5.1.7 前缀格式后缀格式 5.1.8 递增/递减运算符指针 5.1.9 组合赋值运算符 5.1.10 复合语句(语句块) 5.1.11 其他语法技巧--逗号运算符 5.1.12 关系表达式 5.1.13 赋值、比较...
  • 面试题206 C++C定义结构的区别什么(摩托罗拉笔试题) 面试题207 关于构造函数析构函数 面试题208 对拷贝构造函数的深拷贝、浅拷贝临时对象的理解 面试题209 基类中有一个虚函数,子类还需要申明为virtual吗...
  • 4、队列和栈有什么区别? 队列先进先出,后进先出 5、写出下列代码的输出内容 #include int inc(int a) { return(++a); } int multi(int*a,int*b,int*c) { return(*c=*a**b); } typedef int(FUNC1)(int in); ...
  • C++程序员面试宝典

    热门讨论 2013-04-01 13:36:19
    面试题61 for循环语句的计算顺序是什么 61 面试题62 while循环与do-while循环有什么区别 62 面试题63 典型循环语句 64 面试题64 break语句与continue语句有什么区别 64 5.3 switch语句 66 面试题65 switch语句的执行...
  • go扩容和栈缩容,连续的缺点 golang怎么做代码优化 golang隐藏技能:怎么访问私有成员 问题排查 trace pprof 源码阅读 sync.map net/http i/o timeout , 希望你不要踩到这个net/http包的坑 mutex ...
  • java范例开发大全(pdf&源码)

    热门讨论 2013-07-04 13:04:40
    实例215 利用将字符串逆序输出 381 实例216 动态的数组链表 382 实例217 你能猜出鱼谁的宠物吗? 387 实例218 使用Collections类对List的排序操作 393 实例219 LinkedList的添加删除操作 395 实例220 运用Vector...
  • Java范例开发大全 (源程序)

    热门讨论 2011-04-27 07:47:22
     实例215 利用将字符串逆序输出 381  实例216 动态的数组链表 382  实例217 你能猜出鱼谁的宠物吗? 387  实例218 使用Collections类对List的排序操作 393  实例219 LinkedList的添加删除操作 395  ...
  • java范例开发大全源代码

    热门讨论 2011-10-30 23:31:51
     实例162 求自定义几何图形的面积周长 252  实例163 使用抽象方法实现的支票夹 254  9.2 封装 257  实例164 世界小姐参赛资格 257  实例165 自定义复数类 261  9.3 继承 264  实例166 轿车与...
  • java范例开发大全

    2013-03-08 20:06:54
    实例215 利用将字符串逆序输出 381 实例216 动态的数组链表 382 实例217 你能猜出鱼谁的宠物吗? 387 实例218 使用Collections类对List的排序操作 393 实例219 LinkedList的添加删除操作 395 实例220 运用Vector...
  • Java范例开发大全(全书源程序)

    热门讨论 2013-04-05 11:50:26
    实例215 利用将字符串逆序输出 381 实例216 动态的数组链表 382 实例217 你能猜出鱼谁的宠物吗? 387 实例218 使用Collections类对List的排序操作 393 实例219 LinkedList的添加删除操作 395 实例220 运用...

空空如也

空空如也

1 2
收藏数 30
精华内容 12
关键字:

栈和队列是顺序存储结构吗