初试811-数据结构(C语言)

第四章：数组和矩阵 

知识点：

数组（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;
        }
    }
};