学习数据结构与算法的心得体会
1.软件设计思想---分层
逻辑层:实现功能需求的,
物理层:用语言开发,性能方面,实现方式
如,数组(ArrayList)、单链表(LinkedList)(物理层)实现List接口(逻辑层),List接口具有一些增删改查的功能
二叉树,以数组形式实现
二叉树就是逻辑层,数组是物理层
树是一个非线性结构,映射到物理层以线性结构存储起来
如下图所示,常见的数据结构可分为「线性数据结构」与「非线性数据结构」,具体为:「数组」、「链表」、「栈」、「队列」、「树」、「图」、「散列表」、「堆」。
1.1 数组
数组是将相同类型的元素存储于连续内存空间的数据结构,其长度不可变。
1.1.1 普通数组
如下图所示,构建此数组需要在初始化时给定长度,并对数组每个索引元素赋值,代码如下:
1 2 3 4 5 6 7 8 | // 初始化一个长度为 5 的数组 array int [] array = new int [ 5 ]; // 元素赋值 array[ 0 ] = 2 ; array[ 1 ] = 3 ; array[ 2 ] = 1 ; array[ 3 ] = 0 ; array[ 4 ] = 2 ; |
或者可以使用直接赋值的初始化方式,代码如下:
1 | int [] array = { 2 , 3 , 1 , 0 , 2 }; |
1.1.2 可变数组
「可变数组」是经常使用的数据结构,其基于数组和扩容机制实现,相比普通数组更加灵活。常用操作有:访问元素、添加元素、删除元素。
Java
1 2 3 4 5 6 7 8 9 | // 初始化可变数组 List<Integer> array = new ArrayList<>(); // 向尾部添加元素 array.add( 2 ); array.add( 3 ); array.add( 1 ); array.add( 0 ); array.add( 2 ); |
python
1 2 3 4 5 6 7 8 9 | # 初始化可变数组 array = [] # 向尾部添加元素 array.append( 2 ) array.append( 3 ) array.append( 1 ) array.append( 0 ) array.append( 2 ) |
1.2 链表
链表以节点为单位,每个元素都是一个独立对象,在内存空间的存储是非连续的。链表的节点对象具有两个成员变量:「值 val
」,「后继节点引用 next
」 。
Java
1 2 3 4 5 | class ListNode { int val; // 节点值 ListNode next; // 后继节点引用 ListNode( int x) { val = x; } } |
Python
1 2 3 4 | class ListNode: def __init__(self, x): self.val = x # 节点值 self.next = None # 后继节点引用 |
如下图所示,建立此链表需要实例化每个节点,并构建各节点的引用指向。
Java
1 2 3 4 5 6 7 8 | // 实例化节点 ListNode n1 = new ListNode( 4 ); // 节点 head ListNode n2 = new ListNode( 5 ); ListNode n3 = new ListNode( 1 ); // 构建引用指向 n1.next = n2; n2.next = n3; |
Python
1 2 3 4 5 6 7 8 | # 实例化节点 n1 = ListNode( 4 ) # 节点 head n2 = ListNode( 5 ) n3 = ListNode( 1 ) # 构建引用指向 n1.next = n2 n2.next = n3 |
1.3 栈
栈是一种具有 「先入后出」 特点的抽象数据结构,可使用数组或链表实现。
Java
1 | Stack<Integer> stack = new Stack<>(); |
Python
1 | stack = [] # Python 可将列表作为栈使用 |
如下图所示,通过常用操作「入栈 push()
」,「出栈 pop()
」,展示了栈的先入后出特性。
Java
1 2 3 4 | stack.push( 1 ); // 元素 1 入栈 stack.push( 2 ); // 元素 2 入栈 stack.pop(); // 出栈 -> 元素 2 stack.pop(); // 出栈 -> 元素 1 |
Python
1 2 3 4 | stack.append( 1 ) # 元素 1 入栈 stack.append( 2 ) # 元素 2 入栈 stack.pop() # 出栈 -> 元素 2 stack.pop() # 出栈 -> 元素 1 |
注意:通常情况下,不推荐使用 Java 的 Vector
以及其子类 Stack
,而一般将 LinkedList
作为栈来使用
1 2 3 4 5 6 | LinkedList<Integer> stack = new LinkedList<>(); stack.addLast( 1 ); // 元素 1 入栈 stack.addLast( 2 ); // 元素 2 入栈 stack.removeLast(); // 出栈 -> 元素 2 stack.removeLast(); // 出栈 -> 元素 1 |
1.3 队列
队列是一种具有 「先入先出」 特点的抽象数据结构,可使用链表实现。
Java
1 | Queue<Integer> queue = new LinkedList<>(); |
Python
1 2 3 4 | # Python 通常使用双端队列 collections.deque from collections import deque queue = deque() |
如下图所示,通过常用操作「入队 push()
」,「出队 pop()
」,展示了队列的先入先出特性。
Java
1 2 3 4 | queue.offer( 1 ); // 元素 1 入队 queue.offer( 2 ); // 元素 2 入队 queue.poll(); // 出队 -> 元素 1 queue.poll(); // 出队 -> 元素 2 |
Python
1 2 3 4 | queue.append( 1 ) # 元素 1 入队 queue.append( 2 ) # 元素 2 入队 queue.popleft() # 出队 -> 元素 1 queue.popleft() # 出队 -> 元素 2 |
1.4 树
树是一种非线性数据结构,根据子节点数量可分为 「二叉树」 和 「多叉树」,最顶层的节点称为「根节点 root」。以二叉树为例,每个节点包含三个成员变量:「值 val」、「左子节点 left」、「右子节点 right」 。
Java
1 2 3 4 5 6 | class TreeNode { int val; // 节点值 TreeNode left; // 左子节点 TreeNode right; // 右子节点 TreeNode( int x) { val = x; } } |
Python
1 2 3 4 5 | class TreeNode: def __init__(self, x): self.val = x # 节点值 self.left = None # 左子节点 self.right = None # 右子节点 |
如下图所示,建立此二叉树需要实例化每个节点,并构建各节点的引用指向。
Java
1 2 3 4 5 6 7 8 9 10 11 12 | // 初始化节点 TreeNode n1 = new TreeNode( 3 ); // 根节点 root TreeNode n2 = new TreeNode( 4 ); TreeNode n3 = new TreeNode( 5 ); TreeNode n4 = new TreeNode( 1 ); TreeNode n5 = new TreeNode( 2 ); // 构建引用指向 n1.left = n2; n1.right = n3; n2.left = n4; n2.right = n5; |
Python
1 2 3 4 5 6 7 8 9 10 11 12 | # 初始化节点 n1 = TreeNode( 3 ) # 根节点 root n2 = TreeNode( 4 ) n3 = TreeNode( 5 ) n4 = TreeNode( 1 ) n5 = TreeNode( 2 ) # 构建引用指向 n1.left = n2 n1.right = n3 n2.left = n4 n2.right = n5 |
1.5 图
图是一种非线性数据结构,由「节点(顶点)vertex」和「边 edge」组成,每条边连接一对顶点。根据边的方向有无,图可分为「有向图」和「无向图」。本文 以无向图为例 开展介绍。
如下图所示,此无向图的 顶点 和 边 集合分别为:
- 顶点集合: vertices = {1, 2, 3, 4, 5}
- 边集合: edges = {(1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (3, 5), (4, 5)}
表示图的方法通常有两种:
- 邻接矩阵: 使用数组 vertices存储顶点,邻接矩阵 edges存储边; edges[i][j] 代表节点 i + 1 和 节点 j + 1之间是否有边。
Python
1 2 3 4 5 6 | vertices = [ 1 , 2 , 3 , 4 , 5 ] edges = [[ 0 , 1 , 1 , 1 , 1 ], [ 1 , 0 , 0 , 1 , 0 ], [ 1 , 0 , 0 , 0 , 1 ], [ 1 , 1 , 0 , 0 , 1 ], [ 1 , 0 , 1 , 1 , 0 ]] |
Java
1 2 3 4 5 6 | int [] vertices = { 1 , 2 , 3 , 4 , 5 }; int [][] edges = {{ 0 , 1 , 1 , 1 , 1 }, { 1 , 0 , 0 , 1 , 0 }, { 1 , 0 , 0 , 0 , 1 }, { 1 , 1 , 0 , 0 , 1 }, { 1 , 0 , 1 , 1 , 0 }}; |
2.邻接表: 使用数组 vertices存储顶点,邻接表 edges 存储边。 edges 为一个二维容器,第一维 i 代表顶点索引,第二维 edges[i]存储此顶点对应的边集和;
例如 edges[0] = [1, 2, 3, 4] 代表 vertices[0] 的边集合为 [1, 2, 3, 4] 。
Python
1 2 3 4 5 6 | vertices = [ 1 , 2 , 3 , 4 , 5 ] edges = [[ 1 , 2 , 3 , 4 ], [ 0 , 3 ], [ 0 , 4 ], [ 0 , 1 , 4 ], [ 0 , 2 , 3 ]] |
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 | int [] vertices = { 1 , 2 , 3 , 4 , 5 }; List<List<Integer>> edges = new ArrayList<>(); List<Integer> edge_1 = new ArrayList<>(Arrays.asList( 1 , 2 , 3 , 4 )); List<Integer> edge_2 = new ArrayList<>(Arrays.asList( 0 , 3 )); List<Integer> edge_3 = new ArrayList<>(Arrays.asList( 0 , 4 )); List<Integer> edge_4 = new ArrayList<>(Arrays.asList( 0 , 1 , 4 )); List<Integer> edge_5 = new ArrayList<>(Arrays.asList( 0 , 2 , 3 )); edges.add(edge_1); edges.add(edge_2); edges.add(edge_3); edges.add(edge_4); edges.add(edge_5); |
注意:
邻接矩阵 VS 邻接表 :
邻接矩阵的大小只与节点数量有关,即 N2,其中 N 为节点数量。因此,当边数量明显少于节点数量时,使用邻接矩阵存储图会造成较大的内存浪费。
因此,邻接表 适合存储稀疏图(顶点较多、边较少); 邻接矩阵 适合存储稠密图(顶点较少、边较多)。
1.6 散列表
散列表是一种非线性数据结构,通过利用 Hash 函数将指定的「键 key
」映射至对应的「值 value
」,以实现高效的元素查找。
例子:设想一个简单场景:小力、小特、小扣的学号分别为 10001, 10002, 10003 。现需求从「姓名」查找「学号」。
则可通过建立姓名为 key
,学号为 value
的散列表实现此需求,代码如下:
Java
1 2 3 4 5 6 7 8 9 10 11 12 | // 初始化散列表 Map<String, Integer> dic = new HashMap<>(); // 添加 key -> value 键值对 dic.put( "小力" , 10001 ); dic.put( "小特" , 10002 ); dic.put( "小扣" , 10003 ); // 从姓名查找学号 dic.get( "小力" ); // -> 10001 dic.get( "小特" ); // -> 10002 dic.get( "小扣" ); // -> 10003 |
Python
1 2 3 4 5 6 7 8 9 10 11 12 | # 初始化散列表 dic = {} # 添加 key -> value 键值对 dic[ "小力" ] = 10001 dic[ "小特" ] = 10002 dic[ "小扣" ] = 10003 # 从姓名查找学号 dic[ "小力" ] # -> 10001 dic[ "小特" ] # -> 10002 dic[ "小扣" ] # -> 10003 |
自行设计Hash函数
例子:假设需求:从「学号」查找「姓名」
将三人的姓名存储至以下数组中,则各姓名在数组中的索引分别为 0, 1, 2 。
Java
1 | String[] names = { "小力" , "小特" , "小扣" }; |
Python
1 | names = [ "小力" , "小特" , "小扣" ] |
此时,我们构造一个简单的 Hash 函数( \%% 为取余符号 ),公式和封装函数如下所示:
Java
1 2 3 4 | int hash( int id) { int index = (id - 1 ) % 10000 ; return index; } |
Python
1 2 3 | def hash(id): index = (id - 1 ) % 10000 return index |
则我们构建了以学号为 key 、姓名对应的数组索引为 value 的散列表。利用此 Hash 函数,则可在 O(1)时间复杂度下通过学号查找到对应姓名,即:
1 2 3 | names[hash( 10001 )] // 小力 names[hash( 10002 )] // 小特 names[hash( 10003 )] // 小扣 |
以上设计只适用于此示例,实际的 Hash 函数需保证低碰撞率、 高鲁棒性等,以适用于各类数据和场景。
1.7 堆
堆是一种基于「完全二叉树」的数据结构,可使用数组实现。以堆为原理的排序算法称为「堆排序」,基于堆实现的数据结构为「优先队列」。
堆分为「大顶堆」和「小顶堆」,大(小)顶堆:任意节点的值不大于(小于)其父节点的值。
完全二叉树定义: 设二叉树深度为 k ,若二叉树除第 k 层外的其它各层(第 1 至 k−1 层)的节点达到最大个数,且处于第 k 层的节点都连续集中在最左边,则称此二叉树为完全二叉树。
如下图所示,为包含 1, 4, 2, 6, 8
元素的小顶堆。将堆(完全二叉树)中的结点按层编号,即可映射到右边的数组存储形式。
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | // 初始化小顶堆 Queue<Integer> heap = new PriorityQueue<>(); // 元素入堆 heap.add( 1 ); heap.add( 4 ); heap.add( 2 ); heap.add( 6 ); heap.add( 8 ); // 元素出堆(从小到大) heap.poll(); // -> 1 heap.poll(); // -> 2 heap.poll(); // -> 4 heap.poll(); // -> 6 heap.poll(); // -> 8 |
Python
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | from heapq import heappush, heappop # 初始化小顶堆 heap = [] # 元素入堆 heappush(heap, 1 ) heappush(heap, 4 ) heappush(heap, 2 ) heappush(heap, 6 ) heappush(heap, 8 ) # 元素出堆(从小到大) heappop(heap) # -> 1 heappop(heap) # -> 2 heappop(heap) # -> 4 heappop(heap) # -> 6 heappop(heap) # -> 8 |
2.算法思想
(1)算法思想,就是在我们遇到问题时候,没有什么思路的时候,就可以朝这些方向去想,如;递归,动态规划,分治算法,查找
计算机里面的都是离散的,证明离散最好的方法,就是用数学归纳法
数学归纳法就是算法思想
递归,在逻辑层,是数学归纳法的体现;在物理层,是程序调用栈的使用
(2)遍历算法(每个节点只能访问一遍)
深度优先:
广度优先:
按层次遍历,使用队列
参考:https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/50e446/
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步