数据结构
- 数组
- 定义：数组是一种线性数据结构，它使用一组连续的内存空间来存储相同类型的数据元素。
- 特点：
- 存储效率高：数组在内存中是连续存储的，因此空间利用率高。
- 随机访问：可以通过索引快速访问数组中的任意元素，时间复杂度为O(1)。
- 长度固定：在声明数组时，其长度是固定的，不能动态改变。
- 应用场景：适用于需要频繁随机访问元素的场景，如存储和操作大量同类型数据。
- 栈
- 定义栈：是一种特殊的线性表，它只允许在表的一端进行插入和删除操作。这一端被称为栈顶，另一端被称为栈底。
- 特点：
- 后进先出（LIFO）：最后被压入栈的元素最先被弹出。
- 操作简单：主要操作是压栈（push）和弹栈（pop），以及查看栈顶元素（peek）。
- 应用场景：常用于函数调用、表达式求值、括号匹配等场景。
- 队列
- 定义：队列是一种特殊的线性表，它只允许在表的一端进行插入操作，在另一端进行删除操作。允许插入的一端称为队尾，允许删除的一端称为队头。
- 特点：
- 先进先出（FIFO）：先插入的元素先被删除。
- 操作简单：主要操作是入队（enqueue）和出队（dequeue）。
- 应用场景：适用于任务调度、消息传递等场景，如打印机任务队列、线程池任务队列等。
- 树与二叉树
- 树：
- 定义：树是一种非线性数据结构，它由n（n≥0）个有限节点组成一个具有层次关系的集合。
- 特点：每个节点有零个或多个子节点，但只有一个父节点（根节点除外）。
- 二叉树：
- 定义：二叉树是一种特殊的树，每个节点最多有两个子节点，分别称为左子节点和右子节点。
- 特点：
- 结构简单：每个节点最多有两个子节点，便于操作和遍历。
- 多种遍历方式：包括前序遍历、中序遍历、后序遍历和层次遍历等。
- 应用场景：二叉树广泛应用于文件系统、数据库索引、表达式树等场景。
- 树：
- 图
- 定义：图是一种非线性数据结构，它由一组顶点和一组边组成，每条边连接两个顶点。
- 特点：
- 复杂结构：顶点之间可以存在任意关系，没有固定的层次结构。
- 多种类型：有无向图和有向图，有加权图和无权图等。
- 应用场景：适用于社交网络、交通网络、通信网络等场景，如最短路径问题、最小生成树问题等。
算法
- 查找
- 线性查找：
- 原理：从数组的第一个元素开始，逐个与目标值进行比较，直到找到目标值或遍历完数组。
- 时间复杂度：O(n)，n为数组长度。
- 适用场景：适用于无序数组或数据量较小的情况。
- 二分查找：
- 原理：在有序数组中，每次取中间元素与目标值进行比较，根据比较结果缩小搜索范围，直到找到目标值或搜索范围为空。
- 时间复杂度：O(logn)，n为数组长度。
- 适用场景：适用于有序数组，查找效率高。
- 线性查找：
- 排序
- 冒泡排序：
- 原理：通过相邻元素的比较和交换，将较大的元素逐渐“冒泡”到数组的末尾，直到整个数组有序。
- 时间复杂度：O(n²)，n为数组长度。
- 特点：简单易懂，但效率较低。
- 选择排序：
- 原理：每次从未排序的部分选择最小（或最大）的元素，放到已排序部分的末尾，直到整个数组有序。
- 时间复杂度：O(n²)，n为数组长度。
- 特点：简单易懂，但效率较低。
- 插入排序：
- 原理：将一个记录插入到已排序好的有序表中，从而得到一个新的、记录数增加1的有序表，直到整个数组有序。
- 时间复杂度：O(n²)，n为数组长度。
- 特点：简单易懂，对部分有序的数组效率较高。
- 快速排序：
- 原理：通过分治法，选择一个基准元素，将数组分为小于基准和大于基准两部分，然后递归地对两部分进行排序。
- 时间复杂度：平均情况下为O(nlogn)，最坏情况下为O(n²)，n为数组长度。
- 特点：效率高，是实际应用中常用的排序算法之一。
- 归并排序：
- 原理：通过分治法，将数组分成若干子数组，对子数组进行排序，然后将有序的子数组合并成一个有序的数组。
- 时间复杂度：O(nlogn)，n为数组长度。
- 特点：稳定排序，但需要额外的存储空间。
- 堆排序：
- 原理：利用堆这种数据结构所设计的一种排序算法，通过构建最大堆或最小堆，然后不断调整堆结构，得到有序的数组。
- 时间复杂度：O(nlogn)，n为数组长度。
- 特点：不需要额外的存储空间，但实现相对复杂。
- 冒泡排序：
- 常见算法
- 深度优先搜索（DFS）：
- 原理：从一个节点开始，沿着一条路径尽可能深地搜索，直到无法继续为止，然后回溯到上一个节点，继续搜索其他路径。
- 特点：适合解决连通性问题、迷宫问题等，通常使用递归或栈实现。
- 广度优先搜索（BFS）：
- 原理：从一个节点开始，逐层遍历图或树的节点，直到找到目标节点或遍历完所有节点。
- 特点：适合解决最短路径问题、层次遍历问题等，通常使用队列实现。
- 动态规划：
- 原理：将复杂问题分解为多个子问题，通过求解子问题并存储子问题的解，避免重复计算，从而得到原问题的解。
- 特点：适用于具有重叠子问题和最优子结构的问题，如背包问题、最长公共子序列问题等。
- 贪心算法：
- 原理：在每一步选择中都采取当前状态下最优的选择，从而希望导致结果是全局最优的。
- 特点：简单高效，但不保证得到全局最优解，适用于一些特定问题，如活动安排问题、霍夫曼编码等。
- 深度优先搜索（DFS）：
数据结构与算法基础概念解析
一、数组（Array）
定义：由相同类型元素组成的有序集合，在内存中连续存储。
特点：
- 随机访问高效：通过下标直接定位元素，时间复杂度为O(1)。
- 插入/删除低效：需移动后续元素，时间复杂度为O(n)。
应用场景：实现哈希表、矩阵运算、缓存池等。
示例：
# 一维数组
arr = [1, 2, 3, 4, 5]
print(arr[2]) # 输出3
# 二维数组
matrix = [[1, 2], [3, 4], [5, 6]]
print(matrix[1][0]) # 输出3
二、栈（Stack）
定义：遵循后进先出（LIFO） 原则的线性数据结构。
核心操作：
- 入栈（Push）：添加元素到栈顶。
- 出栈（Pop）：从栈顶移除元素。
应用场景：函数调用栈、表达式求值（如括号匹配）、DFS遍历。
示例（Python实现）：
stack = []
stack.append(1) # 入栈1
stack.append(2) # 入栈2
print(stack.pop()) # 出栈2，输出2
print(stack) # 剩余[1]
三、队列（Queue）
定义：遵循先进先出（FIFO） 原则的线性数据结构。
核心操作：
- 入队（Enqueue）：添加元素到队尾。
- 出队（Dequeue）：从队头移除元素。
变种： - 优先队列：按优先级出队（如堆实现）。
- 双端队列（Deque）：两端均可插入/删除。
应用场景：任务调度、BFS遍历、打印机排队。
示例（Python实现）：
from collections import deque
queue = deque()
queue.append(1) # 入队1
queue.append(2) # 入队2
print(queue.popleft()) # 出队1，输出1
print(queue) # 剩余deque([2])
四、树与二叉树（Tree & Binary Tree）
树的定义：n个节点的有限集合，有且仅有一个根节点，子树互不相交。
二叉树特点：每个节点最多有两个子节点（左子树、右子树）。
常见类型：
- 满二叉树：除叶子节点外，每个节点都有两个子节点。
- 完全二叉树：除最后一层外，其他层节点数满，且最后一层节点靠左排列。
- 二叉搜索树（BST）：左子树节点值<根节点<右子树节点值。
遍历方式：
| 类型 | 顺序 | 示例（根节点为A，左子B，右子C） |
|---|---|---|
| 前序遍历 | 根→左→右 | A→B→C |
| 中序遍历 | 左→根→右 | B→A→C |
| 后序遍历 | 左→右→根 | B→C→A |
| 层序遍历 | 按层从左到右遍历 | A→B→C |
应用场景：文件系统目录结构、霍夫曼编码、数据库索引。
五、图（Graph）
定义：由顶点（Vertex）和边（Edge）组成的非线性结构，用于表示多对多关系。
分类：
- 无向图：边没有方向（如社交网络关系）。
- 有向图：边有方向（如网页链接）。
- 带权图：边附带权重（如地图路径距离）。
存储方式： - 邻接矩阵：用二维数组表示顶点间连接关系，适合稠密图。
- 邻接表：用链表数组存储，适合稀疏图。
经典算法： - 最短路径：Dijkstra算法、Floyd算法。
- 遍历：DFS（深度优先搜索）、BFS（广度优先搜索）。
- 拓扑排序：用于有向无环图（DAG）的任务调度。
应用场景：社交网络分析、交通路线规划、推荐系统。
六、查找与排序
1. 查找算法
| 算法 | 时间复杂度 | 适用场景 | 特点 |
|---|---|---|---|
| 顺序查找 | O(n) | 无序数组 | 简单但效率低 |
| 二分查找 | O(log n) | 有序数组 | 每次将查找范围减半 |
| 哈希查找 | O(1) | 键值对存储（如字典） | 利用哈希函数映射，需处理冲突 |
二分查找示例（Python）：
def binary_search(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
arr = [1, 3, 5, 7, 9]
print(binary_search(arr, 5)) # 输出2
2. 排序算法
| 算法 | 时间复杂度 | 稳定性 | 特点 |
|---|---|---|---|
| 冒泡排序 | O(n²) | 稳定 | 相邻元素比较，交换位置 |
| 快速排序 | 平均O(n log n) | 不稳定 | 分治法，选基准值分区 |
| 归并排序 | O(n log n) | 稳定 | 分治法，合并有序子数组 |
| 堆排序 | O(n log n) | 不稳定 | 利用堆数据结构实现 |
| 插入排序 | O(n²) | 稳定 | 构建有序序列，插入未排序元素 |
快速排序示例（Python）：
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
arr = [3, 1, 4, 1, 5, 9, 2]
print(quick_sort(arr)) # 输出[1, 1, 2, 3, 4, 5, 9]
七、常见算法思想
1. 分治法（Divide and Conquer）
- 核心：将问题分解为子问题，求解后合并结果。
- 示例：归并排序、快速排序、二分查找。
2. 动态规划（Dynamic Programming）
- 核心：存储子问题解避免重复计算（备忘录/填表）。
- 条件：问题具有最优子结构和重叠子问题。
- 示例：斐波那契数列（优化版）、背包问题、最长公共子序列。
3. 贪心算法（Greedy Algorithm）
- 核心：每一步选择当前最优解，不考虑全局。
- 示例：霍夫曼编码、最小生成树（Kruskal/Prim算法）、活动选择问题。
4. 回溯算法（Backtracking）
- 核心：通过试错寻找所有可能解，不满足条件时回退。
- 示例：八皇后问题、迷宫寻路、组合生成。
总结与拓展
数据结构是算法的基础，不同结构适用于不同场景：
- 数组适合随机访问，栈和队列适合处理顺序任务。
- 树和图用于表示层级或复杂关系，查找与排序是数据处理的核心操作。
- 算法思想需结合具体问题灵活运用，如动态规划常用于优化递归问题。
数据结构与算法基础概念解析
一、数组（Array）
定义：由相同类型元素组成的有序集合，在内存中连续存储。
特点：
- 随机访问高效：通过下标直接定位元素，时间复杂度为O(1)。
- 插入/删除低效：需移动后续元素，时间复杂度为O(n)。
应用场景：实现哈希表、矩阵运算、缓存池等。
示例：
# 一维数组
arr = [1, 2, 3, 4, 5]
print(arr[2]) # 输出3
# 二维数组
matrix = [[1, 2], [3, 4], [5, 6]]
print(matrix[1][0]) # 输出3
二、栈（Stack）
定义：遵循后进先出（LIFO） 原则的线性数据结构。
核心操作：
- 入栈（Push）：添加元素到栈顶。
- 出栈（Pop）：从栈顶移除元素。
应用场景：函数调用栈、表达式求值（如括号匹配）、DFS遍历。
示例（Python实现）：
stack = []
stack.append(1) # 入栈1
stack.append(2) # 入栈2
print(stack.pop()) # 出栈2，输出2
print(stack) # 剩余[1]
三、队列（Queue）
定义：遵循先进先出（FIFO） 原则的线性数据结构。
核心操作：
- 入队（Enqueue）：添加元素到队尾。
- 出队（Dequeue）：从队头移除元素。
变种： - 优先队列：按优先级出队（如堆实现）。
- 双端队列（Deque）：两端均可插入/删除。
应用场景：任务调度、BFS遍历、打印机排队。
示例（Python实现）：
from collections import deque
queue = deque()
queue.append(1) # 入队1
queue.append(2) # 入队2
print(queue.popleft()) # 出队1，输出1
print(queue) # 剩余deque([2])
四、树与二叉树（Tree & Binary Tree）
树的定义：n个节点的有限集合，有且仅有一个根节点，子树互不相交。
二叉树特点：每个节点最多有两个子节点（左子树、右子树）。
常见类型：
- 满二叉树：除叶子节点外，每个节点都有两个子节点。
- 完全二叉树：除最后一层外，其他层节点数满，且最后一层节点靠左排列。
- 二叉搜索树（BST）：左子树节点值<根节点<右子树节点值。
遍历方式：
| 类型 | 顺序 | 示例（根节点为A，左子B，右子C） |
|---|---|---|
| 前序遍历 | 根→左→右 | A→B→C |
| 中序遍历 | 左→根→右 | B→A→C |
| 后序遍历 | 左→右→根 | B→C→A |
| 层序遍历 | 按层从左到右遍历 | A→B→C |
应用场景：文件系统目录结构、霍夫曼编码、数据库索引。
五、图（Graph）
定义：由顶点（Vertex）和边（Edge）组成的非线性结构，用于表示多对多关系。
分类：
- 无向图：边没有方向（如社交网络关系）。
- 有向图：边有方向（如网页链接）。
- 带权图：边附带权重（如地图路径距离）。
存储方式： - 邻接矩阵：用二维数组表示顶点间连接关系，适合稠密图。
- 邻接表：用链表数组存储，适合稀疏图。
经典算法： - 最短路径：Dijkstra算法、Floyd算法。
- 遍历：DFS（深度优先搜索）、BFS（广度优先搜索）。
- 拓扑排序：用于有向无环图（DAG）的任务调度。
应用场景：社交网络分析、交通路线规划、推荐系统。
六、查找与排序
1. 查找算法
| 算法 | 时间复杂度 | 适用场景 | 特点 |
|---|---|---|---|
| 顺序查找 | O(n) | 无序数组 | 简单但效率低 |
| 二分查找 | O(log n) | 有序数组 | 每次将查找范围减半 |
| 哈希查找 | O(1) | 键值对存储（如字典） | 利用哈希函数映射，需处理冲突 |
二分查找示例（Python）：
def binary_search(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
arr = [1, 3, 5, 7, 9]
print(binary_search(arr, 5)) # 输出2
2. 排序算法
| 算法 | 时间复杂度 | 稳定性 | 特点 |
|---|---|---|---|
| 冒泡排序 | O(n²) | 稳定 | 相邻元素比较，交换位置 |
| 快速排序 | 平均O(n log n) | 不稳定 | 分治法，选基准值分区 |
| 归并排序 | O(n log n) | 稳定 | 分治法，合并有序子数组 |
| 堆排序 | O(n log n) | 不稳定 | 利用堆数据结构实现 |
| 插入排序 | O(n²) | 稳定 | 构建有序序列，插入未排序元素 |
快速排序示例（Python）：
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
arr = [3, 1, 4, 1, 5, 9, 2]
print(quick_sort(arr)) # 输出[1, 1, 2, 3, 4, 5, 9]
七、常见算法思想
1. 分治法（Divide and Conquer）
- 核心：将问题分解为子问题，求解后合并结果。
- 示例：归并排序、快速排序、二分查找。
2. 动态规划（Dynamic Programming）
- 核心：存储子问题解避免重复计算（备忘录/填表）。
- 条件：问题具有最优子结构和重叠子问题。
- 示例：斐波那契数列（优化版）、背包问题、最长公共子序列。
3. 贪心算法（Greedy Algorithm）
- 核心：每一步选择当前最优解，不考虑全局。
- 示例：霍夫曼编码、最小生成树（Kruskal/Prim算法）、活动选择问题。
4. 回溯算法（Backtracking）
- 核心：通过试错寻找所有可能解，不满足条件时回退。
- 示例：八皇后问题、迷宫寻路、组合生成。
总结与拓展
数据结构是算法的基础，不同结构适用于不同场景：
- 数组适合随机访问，栈和队列适合处理顺序任务。
- 树和图用于表示层级或复杂关系，查找与排序是数据处理的核心操作。
- 算法思想需结合具体问题灵活运用，如动态规划常用于优化递归问题。
建议通过LeetCode等平台练习实战，深入理解各类结构与算法的性能特点和适用场景。。### 数据结构与算法基础概念解析
一、数组（Array）
定义：由相同类型元素组成的有序集合，在内存中连续存储。
特点：
- 随机访问高效：通过下标直接定位元素，时间复杂度为O(1)。
- 插入/删除低效：需移动后续元素，时间复杂度为O(n)。
应用场景：实现哈希表、矩阵运算、缓存池等。
示例：
# 一维数组
arr = [1, 2, 3, 4, 5]
print(arr[2]) # 输出3
# 二维数组
matrix = [[1, 2], [3, 4], [5, 6]]
print(matrix[1][0]) # 输出3
二、栈（Stack）
定义：遵循后进先出（LIFO） 原则的线性数据结构。
核心操作：
- 入栈（Push）：添加元素到栈顶。
- 出栈（Pop）：从栈顶移除元素。
应用场景：函数调用栈、表达式求值（如括号匹配）、DFS遍历。
示例（Python实现）：
stack = []
stack.append(1) # 入栈1
stack.append(2) # 入栈2
print(stack.pop()) # 出栈2，输出2
print(stack) # 剩余[1]
三、队列（Queue）
定义：遵循先进先出（FIFO） 原则的线性数据结构。
核心操作：
- 入队（Enqueue）：添加元素到队尾。
- 出队（Dequeue）：从队头移除元素。
变种： - 优先队列：按优先级出队（如堆实现）。
- 双端队列（Deque）：两端均可插入/删除。
应用场景：任务调度、BFS遍历、打印机排队。
示例（Python实现）：
from collections import deque
queue = deque()
queue.append(1) # 入队1
queue.append(2) # 入队2
print(queue.popleft()) # 出队1，输出1
print(queue) # 剩余deque([2])
四、树与二叉树（Tree & Binary Tree）
树的定义：n个节点的有限集合，有且仅有一个根节点，子树互不相交。
二叉树特点：每个节点最多有两个子节点（左子树、右子树）。
常见类型：
- 满二叉树：除叶子节点外，每个节点都有两个子节点。
- 完全二叉树：除最后一层外，其他层节点数满，且最后一层节点靠左排列。
- 二叉搜索树（BST）：左子树节点值<根节点<右子树节点值。
遍历方式：
| 类型 | 顺序 | 示例（根节点为A，左子B，右子C） |
|---|---|---|
| 前序遍历 | 根→左→右 | A→B→C |
| 中序遍历 | 左→根→右 | B→A→C |
| 后序遍历 | 左→右→根 | B→C→A |
| 层序遍历 | 按层从左到右遍历 | A→B→C |
应用场景：文件系统目录结构、霍夫曼编码、数据库索引。
五、图（Graph）
定义：由顶点（Vertex）和边（Edge）组成的非线性结构，用于表示多对多关系。
分类：
- 无向图：边没有方向（如社交网络关系）。
- 有向图：边有方向（如网页链接）。
- 带权图：边附带权重（如地图路径距离）。
存储方式： - 邻接矩阵：用二维数组表示顶点间连接关系，适合稠密图。
- 邻接表：用链表数组存储，适合稀疏图。
经典算法： - 最短路径：Dijkstra算法、Floyd算法。
- 遍历：DFS（深度优先搜索）、BFS（广度优先搜索）。
- 拓扑排序：用于有向无环图（DAG）的任务调度。
应用场景：社交网络分析、交通路线规划、推荐系统。
六、查找与排序
1. 查找算法
| 算法 | 时间复杂度 | 适用场景 | 特点 |
|---|---|---|---|
| 顺序查找 | O(n) | 无序数组 | 简单但效率低 |
| 二分查找 | O(log n) | 有序数组 | 每次将查找范围减半 |
| 哈希查找 | O(1) | 键值对存储（如字典） | 利用哈希函数映射，需处理冲突 |
二分查找示例（Python）：
def binary_search(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
arr = [1, 3, 5, 7, 9]
print(binary_search(arr, 5)) # 输出2
2. 排序算法
| 算法 | 时间复杂度 | 稳定性 | 特点 |
|---|---|---|---|
| 冒泡排序 | O(n²) | 稳定 | 相邻元素比较，交换位置 |
| 快速排序 | 平均O(n log n) | 不稳定 | 分治法，选基准值分区 |
| 归并排序 | O(n log n) | 稳定 | 分治法，合并有序子数组 |
| 堆排序 | O(n log n) | 不稳定 | 利用堆数据结构实现 |
| 插入排序 | O(n²) | 稳定 | 构建有序序列，插入未排序元素 |
快速排序示例（Python）：
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
arr = [3, 1, 4, 1, 5, 9, 2]
print(quick_sort(arr)) # 输出[1, 1, 2, 3, 4, 5, 9]
七、常见算法思想
1. 分治法（Divide and Conquer）
- 核心：将问题分解为子问题，求解后合并结果。
- 示例：归并排序、快速排序、二分查找。
2. 动态规划（Dynamic Programming）
- 核心：存储子问题解避免重复计算（备忘录/填表）。
- 条件：问题具有最优子结构和重叠子问题。
- 示例：斐波那契数列（优化版）、背包问题、最长公共子序列。
3. 贪心算法（Greedy Algorithm）
- 核心：每一步选择当前最优解，不考虑全局。
- 示例：霍夫曼编码、最小生成树（Kruskal/Prim算法）、活动选择问题。
4. 回溯算法（Backtracking）
- 核心：通过试错寻找所有可能解，不满足条件时回退。
- 示例：八皇后问题、迷宫寻路、组合生成。
总结与拓展
数据结构是算法的基础，不同结构适用于不同场景：
- 数组适合随机访问，栈和队列适合处理顺序任务。
- 树和图用于表示层级或复杂关系，查找与排序是数据处理的核心操作。
- 算法思想需结合具体问题灵活运用，如动态规划常用于优化递归问题。
建议通过LeetCode等平台练习实战，深入理解各类结构与算法的性能特点和适用场景。
扫一扫
749
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
