第四章:数组和矩阵
知识点:
数组(array)是一种线性数据结构,其将相同类型的元素存储在连续的内存空间中。我们将元素在数组中的位置称为该元素的索引(index)。
数组的优点与局限性:
数组存储在连续的内存空间内,且元素类型相同。这种做法包含丰富的先验信息,系统可以利用这些信息来优化数据结构的操作效率。
- 空间效率高:数组为数据分配了连续的内存块,无须额外的结构开销。
- 支持随机访问:数组允许在 时间内访问任何元素。
- 缓存局部性:当访问数组元素时,计算机不仅会加载它,还会缓存其周围的其他数据,从而借助高速缓存来提升后续操作的执行速度。
连续空间存储是一把双刃剑,其存在以下局限性。
- 插入与删除效率低:当数组中元素较多时,插入与删除操作需要移动大量的元素。
- 长度不可变:数组在初始化后长度就固定了,扩容数组需要将所有数据复制到新数组,开销很大。
- 空间浪费:如果数组分配的大小超过实际所需,那么多余的空间就被浪费了。
数组典型应用
数组是一种基础且常见的数据结构,既频繁应用在各类算法之中,也可用于实现各种复杂数据结构。
- 随机访问:如果我们想随机抽取一些样本,那么可以用数组存储,并生成一个随机序列,根据索引实现随机抽样。
- 排序和搜索:数组是排序和搜索算法最常用的数据结构。快速排序、归并排序、二分查找等都主要在数组上进行。
- 查找表:当需要快速查找一个元素或其对应关系时,可以使用数组作为查找表。假如我们想实现字符到 ASCII 码的映射,则可以将字符的 ASCII 码值作为索引,对应的元素存放在数组中的对应位置。
- 机器学习:神经网络中大量使用了向量、矩阵、张量之间的线性代数运算,这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
- 数据结构实现:数组可以用于实现栈、队列、哈希表、堆、图等数据结构。例如,图的邻接矩阵表示实际上是一个二维数组。
相关考法🌈🌽:
-
数组矩阵
-
弱点
-
下标映射
-
对称矩阵映射公式
-
三对角矩阵映射公式
-
已知k,求i行
-
根据K=2i+j-3,求j列
-
-
-
-
考题
-
P108、t8、t11、t14
-
-
- 概要
Q&A:
1、请给出对称矩阵的ADT描述。
ADT SymmetricMatrix {
数据对象: 一个 n x n 的方阵,其中对称性条件 A[i][j] == A[j][i] 对于所有 i 和 j 成立。
数据操作:
1. Create(int n) // 创建一个 n x n 的对称矩阵
2. GetElement(int i, int j) -> ElementType // 获取矩阵中第 i 行第 j 列的元素值
3. SetElement(int i, int j, ElementType x) // 将矩阵中第 i 行第 j 列的元素值设为 x
4. Display() // 显示矩阵
}
2、编写程序实现行优先存储的下三角矩阵的查找算法、元素赋值运算与矩阵输出运算。
#include <iostream>
#include <vector>
class LowerTriangularMatrix {
std::vector<int> data; // 存储下三角矩阵的元素
int n; // 矩阵的维数
public:
LowerTriangularMatrix(int size) : n(size) {
data.resize(n * (n + 1) / 2);
}
int getIndex(int i, int j) {
if (i < j) return -1;
return (i * (i + 1)) / 2 + j;
}
void setElement(int i, int j, int value) {
int index = getIndex(i, j);
if (index != -1)
data[index] = value;
}
int getElement(int i, int j) {
int index = getIndex(i, j);
return index != -1 ? data[index] : 0;
}
void display() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
std::cout << getElement(i, j) << " ";
}
std::cout << std::endl;
}
}
};
3、编写程序实现稀疏矩阵元素的查找运算,并给出算法时间复杂度分析。
#include <iostream>
#include <vector>
struct Element {
int row, col, value;
};
class SparseMatrix {
std::vector<Element> elements; // 三元组存储稀疏矩阵
public:
SparseMatrix(int rows, int cols, const std::vector<Element>& elems) {
elements = elems;
}
int getElement(int row, int col) {
for (const auto& e : elements) {
if (e.row == row && e.col == col)
return e.value;
}
return 0; // 未找到返回 0
}
void display() {
for (const auto& e : elements) {
std::cout << "(" << e.row << ", " << e.col << ", " << e.value << ")" << std::endl;
}
}
};
4、编写程序实现稀疏矩阵的加法运算,并给出算法时间复杂度分析。
#include <iostream>
#include <vector>
struct Element {
int row, col, value;
};
class SparseMatrix {
int rows, cols;
std::vector<Element> elements;
public:
SparseMatrix(int r, int c, const std::vector<Element>& elems) : rows(r), cols(c), elements(elems) {}
SparseMatrix add(const SparseMatrix& other) {
std::vector<Element> resultElements;
size_t i = 0, j = 0;
while (i < elements.size() && j < other.elements.size()) {
if (elements[i].row == other.elements[j].row && elements[i].col == other.elements[j].col) {
int sum = elements[i].value + other.elements[j].value;
if (sum != 0)
resultElements.push_back({elements[i].row, elements[i].col, sum});
i++;
j++;
} else if (elements[i].row < other.elements[j].row ||
(elements[i].row == other.elements[j].row && elements[i].col < other.elements[j].col)) {
resultElements.push_back(elements[i++]);
} else {
resultElements.push_back(other.elements[j++]);
}
}
while (i < elements.size()) resultElements.push_back(elements[i++]);
while (j < other.elements.size()) resultElements.push_back(other.elements[j++]);
return SparseMatrix(rows, cols, resultElements);
}
void display() {
for (const auto& e : elements) {
std::cout << "(" << e.row << ", " << e.col << ", " << e.value << ")" << std::endl;
}
}
};
5、编写程序实现稀疏矩阵的乘法运算,并给出算法时间复杂度分析。
#include <iostream>
#include <vector>
#include <unordered_map>
struct Element {
int row, col, value;
};
class SparseMatrix {
int rows, cols;
std::vector<Element> elements;
public:
SparseMatrix(int r, int c, const std::vector<Element>& elems) : rows(r), cols(c), elements(elems) {}
SparseMatrix multiply(const SparseMatrix& other) {
std::vector<Element> resultElements;
std::unordered_map<int, std::unordered_map<int, int>> resultMap;
for (const auto& e1 : elements) {
for (const auto& e2 : other.elements) {
if (e1.col == e2.row) {
resultMap[e1.row][e2.col] += e1.value * e2.value;
}
}
}
for (const auto& row : resultMap) {
for (const auto& col : row.second) {
if (col.second != 0) {
resultElements.push_back({row.first, col.first, col.second});
}
}
}
return SparseMatrix(rows, other.cols, resultElements);
}
void display() {
for (const auto& e : elements) {
std::cout << "(" << e.row << ", " << e.col << ", " << e.value << ")" << std::endl;
}
}
};