【数据结构】数组和字符串（十）：稀疏矩阵的链接存储：十字链表的矩阵操作（加法、乘法、转置）

news2024/11/25 12:49:13

文章目录

  • 4.2.1 矩阵的数组表示
  • 4.2.2 特殊矩阵的压缩存储
    • a. 对角矩阵的压缩存储
    • b~c. 三角、对称矩阵的压缩存储
    • d. 稀疏矩阵的压缩存储——三元组表
    • 4.2.3三元组表的转置、加法、乘法、操作
    • 4.2.4十字链表
      • 0. 十字链表的基本操作
      • 1. 矩阵加法
      • 2. 矩阵乘法
      • 3. 矩阵转置
      • 4. 主函数
  • 5. 代码整合

4.2.1 矩阵的数组表示

【数据结构】数组和字符串（一）：矩阵的数组表示

4.2.2 特殊矩阵的压缩存储

  矩阵是以按行优先次序将所有矩阵元素存放在一个一维数组中。但是对于特殊矩阵，如对称矩阵、三角矩阵、对角矩阵和稀疏矩阵等, 如果用这种方式存储，会出现大量存储空间存放重复信息或零元素的情况，这样会造成很大的空间浪费。为节约存储空间和算法（程序）运行时间，通常会采用压缩存储的方法。

  • 对角矩阵：指除了主对角线以外的元素都为零的矩阵，即对 任意 i ≠ j (1≤ i , j ≤n)，都有M(i, j)=0。由于只有主对角线上有非零元素，只需存储主对角线上的元素即可。
  • 三角矩阵：指上三角或下三角的元素都为零的矩阵。同样地，只需存储其中一部分非零元素，可以节省存储空间。
  • 对称矩阵：指矩阵中的元素关于主对角线对称的矩阵。由于对称矩阵的非零元素有一定的规律，可以只存储其中一部分元素，从而减少存储空间。
  • 稀疏矩阵：指大部分元素为零的矩阵。传统的按行优先次序存储方法会浪费大量空间来存储零元素，因此采用压缩存储的方法更为合适。常见的压缩存储方法有：压缩稠密行（CSR）、压缩稠密列（CSC）、坐标列表（COO）等。

a. 对角矩阵的压缩存储

【数据结构】数组和字符串（二）：特殊矩阵的压缩存储：对角矩阵——一维数组

b~c. 三角、对称矩阵的压缩存储

【数据结构】数组和字符串（三）：特殊矩阵的压缩存储：三角矩阵、对称矩阵——一维数组

d. 稀疏矩阵的压缩存储——三元组表

  对于稀疏矩阵的压缩存储，由于非零元素的个数远小于零元素的个数，并且非零元素的分布没有规律，无法简单地利用一维数组和映射公式来实现压缩存储。针对稀疏矩阵，通常采用特定的数据结构来进行压缩存储，以减少存储空间的占用。

  一种常见的稀疏矩阵压缩存储方法是使用"三元组"表示法，也称为COO（Coordinate）格式，只存储非零元素的值以及它们的行列坐标。通过使用三元组（Triplet）来表示非零元素的位置和值，每个三元组包含三个信息：非零元素的行索引、非零元素的列索引以及非零元素的值。

【数据结构】数组和字符串（四）：特殊矩阵的压缩存储：稀疏矩阵——三元组表

4.2.3三元组表的转置、加法、乘法、操作

【数据结构】数组和字符串（七）：特殊矩阵的压缩存储：三元组表的转置、加法、乘法操作

4.2.4十字链表

  在稀疏矩阵的十字链表中，每个非零元素都由一个节点表示。节点包含了几个字段：

  1. LEFT：指向该节点在同一行中的左邻非零元素的地址信息。
  2. UP：指向该节点在同一列中的上邻非零元素的地址信息。
  3. ROW：存储该节点在矩阵中的行号。
  4. COL：存储该节点在矩阵中的列号。
  5. VAL：存储该节点的元素值。

  每一行都有一个表头节点，它引导着该行的循环链表，循环链表中的每个节点按照列号的顺序排列。同样，每一列也有一个表头节点，它引导着该列的循环链表，循环链表中的每个节点按照行号的顺序排列。
  关于循环链表： 【数据结构】线性表（三）循环链表的各种操作（创建、插入、查找、删除、修改、遍历打印、释放内存空间）

在这里插入图片描述

  • 在稀疏矩阵的十字链表中，每一行和每一列都有一个表头节点。

    • 对于行表头节点 BASEROW[i]，其中 i 表示行号，范围从 1 到 m（矩阵的行数）。如果该行为空（即没有非零元素），则 COL(Loc(BASEROW[i])) 的值为 -1。否则，COL(Loc(BASEROW[i])) 的值为该行中最右边的非零元素的列号。

    • 对于列表头节点 BASECOL[j]，其中 j 表示列号，范围从 1 到 n（矩阵的列数）。如果该列为空（即没有非零元素），则 ROW(Loc(BASECOL[j])) 的值为 -1。否则，ROW(Loc(BASECOL[j])) 的值为该列中最下边的非零元素的行号。

  • 由于行和列都是循环链表，行表头节点 BASEROW[i] 中的 LEFT 指针循环地链接到该行最右边的非零元素，列表头节点 BASECOL[j] 中的 UP 指针循环地链接到该列最下边的非零元素。
     
     通过这种方式，可以用较少的空间表示稀疏矩阵，并且可以快速地进行行和列的遍历操作。每个节点的 LEFT 和 UP 指针可以用来定位其左邻和上邻非零元素，从而实现矩阵的访问和操作。

0. 十字链表的基本操作

【数据结构】数组和字符串（八）：稀疏矩阵的链接存储：十字链表的创建、遍历打印（按行、按列、打印矩阵）、销毁

【数据结构】数组和字符串（九）：稀疏矩阵的链接存储：十字链表的插入、查找、删除操作

1. 矩阵加法

SparseMatrix* matrixAddition(SparseMatrix* matrix1, SparseMatrix* matrix2) {
    if (matrix1->rows != matrix2->rows || matrix1->cols != matrix2->cols) {
        printf("Matrix dimensions do not match!\n");
        return NULL;
    }

    SparseMatrix* result = createSparseMatrix(matrix1->rows, matrix1->cols);

    for (int i = 1; i <= matrix1->rows; i++) {
        MatrixNode* node1 = matrix1->rowHeaders[i];
        MatrixNode* node2 = matrix2->rowHeaders[i];

        while (node1 != NULL && node2 != NULL) {
            if (node1->col == node2->col) {
                int sum = node1->value + node2->value;
                insertElement(result, node1->row, node1->col, sum);
                node1 = node1->right;
                node2 = node2->right;
            } else if (node1->col < node2->col) {
                insertElement(result, node1->row, node1->col, node1->value);
                node1 = node1->right;
            } else {
                insertElement(result, node2->row, node2->col, node2->value);
                node2 = node2->right;
            }
        }

        while (node1 != NULL) {
            insertElement(result, node1->row, node1->col, node1->value);
            node1 = node1->right;
        }

        while (node2 != NULL) {
            insertElement(result, node2->row, node2->col, node2->value);
            node2 = node2->right;
        }
    }

    return result;
}
  • 检查两个矩阵的行数和列数是否相同，如果不相同，则打印错误消息并返回NULL。
  • 创建一个新的稀疏矩阵作为结果。
  • 从第一行开始遍历两个矩阵的每一行：
    • 获取第一个矩阵当前行的行链表头节点和第二个矩阵当前行的行链表头节点。
    • 遍历两个矩阵当前行的行链表，根据节点的列进行比较：
      • 如果两个节点的列相等，则将节点的值相加，并插入到结果矩阵中。
      • 如果第一个节点的列小于第二个节点的列，则将第一个节点插入到结果矩阵中。
      • 如果第一个节点的列大于第二个节点的列，则将第二个节点插入到结果矩阵中。
    • 遍历剩余的节点，将它们插入到结果矩阵中。
  • 返回结果稀疏矩阵的指针。

2. 矩阵乘法

SparseMatrix* matrixMultiplication(SparseMatrix* matrix1, SparseMatrix* matrix2) {
    if (matrix1->cols != matrix2->rows) {
        printf("Matrix dimensions do not match!\n");
        return NULL;
    }

    SparseMatrix* result = createSparseMatrix(matrix1->rows, matrix2->cols);

    for (int i = 1; i <= matrix1->rows; i++) {
        for (int j = 1; j <= matrix2->cols; j++) {
            int sum = 0;

            MatrixNode* node1 = matrix1->rowHeaders[i];
            MatrixNode* node2 = matrix2->colHeaders[j];

            while (node1 != NULL && node2 != NULL) {
                if (node1->col == node2->row) {
                    sum += node1->value * node2->value;
                    node1 = node1->right;
                    node2 = node2->down;
                } else if (node1->col < node2->row) {
                    node1 = node1->right;
                } else {
                    node2 = node2->down;
                }
            }

            if (sum != 0) {
                insertElement(result, i, j, sum);
            }
        }
    }

    return result;
}
  • 检查两个矩阵的维度是否满足矩阵乘法的要求，如果不满足，则打印错误消息并返回NULL。
  • 创建一个新的稀疏矩阵作为结果。
  • 从第一行开始遍历第一个矩阵的每一行：
    • 遍历第二个矩阵的每一列：
      • 初始化一个变量用于存储两个节点值的乘积的累加和。
      • 获取第一个矩阵当前行的行链表头节点和第二个矩阵当前列的列链表头节点。
      • 遍历两个链表，根据节点的列和行进行比较：
        • 如果两个节点的列和行相等，则将两个节点的值相乘并累加到和变量中。
        • 如果第一个节点的列小于第二个节点的行，则将第一个节点的右指针向右移动。
        • 如果第一个节点的列大于第二个节点的行，则将第二个节点的下指针向下移动。
      • 如果和变量的值不为0，则将和变量的值插入到结果矩阵中。
  • 返回结果稀疏矩阵的指针。

3. 矩阵转置

SparseMatrix* matrixTranspose(SparseMatrix* matrix) {
    SparseMatrix* result = createSparseMatrix(matrix->cols, matrix->rows);

    for (int i = 1; i <= matrix->rows; i++) {
        MatrixNode* current = matrix->rowHeaders[i];
        while (current != NULL) {
            insertElement(result, current->col, current->row, current->value);
            current = current->right;
        }
    }

    return result;
}
  • 创建一个新的稀疏矩阵作为结果，行数和列数与原矩阵相反。
  • 从第一行开始遍历原矩阵的每一行：
    • 获取当前行的行链表头节点。
    • 遍历当前行的行链表，将节点的行和列交换后插入到结果矩阵中。
  • 返回结果稀疏矩阵的指针。

4. 主函数

int main() {
    // 创建一个5x5的稀疏矩阵
    SparseMatrix* matrix1 = createSparseMatrix(5, 5);

    // 插入元素
    insertElement(matrix1, 1, 3, 5);
    insertElement(matrix1, 1, 4, 2);
    insertElement(matrix1, 5, 2, 1);
    insertElement(matrix1, 5, 1, 8);
    insertElement(matrix1, 5, 5, 7);

    // 打印稀疏矩阵
    printf("\nSparse Matrix 1:\n");
    printSparseMatrix(matrix1);

    // 创建另一个5x3的稀疏矩阵
    SparseMatrix* matrix2 = createSparseMatrix(5, 3);

    // 插入元素
    insertElement(matrix2, 1, 1, 1);
    insertElement(matrix2, 1, 3, 2);
    insertElement(matrix2, 2, 2, 3);
    insertElement(matrix2, 3, 1, 4);
    insertElement(matrix2, 3, 3, 5);

    // 打印稀疏矩阵
    printf("\nSparse Matrix 2:\n");
    printSparseMatrix(matrix2);

    // 矩阵加法
    SparseMatrix* additionResult = matrixAddition(matrix1, matrix1);
    printf("\nMatrix Addition Result:\n");
    printSparseMatrix(additionResult);

    // 矩阵乘法
    SparseMatrix* multiplicationResult = matrixMultiplication(matrix1, matrix2);
    printf("\nMatrix Multiplication Result:\n");
    printSparseMatrix(multiplicationResult);

    // 矩阵转置
    SparseMatrix* transposeResult = matrixTranspose(matrix1);
    printf("\nMatrix Transpose Result:\n");
    printSparseMatrix(transposeResult);

    // 销毁稀疏矩阵
    destroySparseMatrix(matrix1);
    destroySparseMatrix(matrix2);
    destroySparseMatrix(additionResult);
    destroySparseMatrix(multiplicationResult);
    destroySparseMatrix(transposeResult);

    return 0;
}

Sparse Matrix 1:
0 0 5 2 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
8 1 0 0 7

Sparse Matrix 2:
1 0 2
0 3 0
4 0 5
0 0 0
0 0 0

在这里插入图片描述

5. 代码整合

#include <stdio.h>
#include <stdlib.h>

// 定义矩阵节点结构
typedef struct MatrixNode {
    int row;
    int col;
    int value;
    struct MatrixNode* right;
    struct MatrixNode* down;
} MatrixNode;

// 定义稀疏矩阵结构
typedef struct SparseMatrix {
    int rows;
    int cols;
    MatrixNode** rowHeaders;
    MatrixNode** colHeaders;
} SparseMatrix;

// 创建稀疏矩阵
SparseMatrix* createSparseMatrix(int rows, int cols) {
    SparseMatrix* matrix = (SparseMatrix*)malloc(sizeof(SparseMatrix));
    matrix->rows = rows;
    matrix->cols = cols;

    // 创建行表头节点数组
    matrix->rowHeaders = (MatrixNode**)malloc((rows + 1) * sizeof(MatrixNode*));
    for (int i = 0; i <= rows; i++) {
        matrix->rowHeaders[i] = NULL;
    }

    // 创建列表头节点数组
    matrix->colHeaders = (MatrixNode**)malloc((cols + 1) * sizeof(MatrixNode*));
    for (int j = 0; j <= cols; j++) {
        matrix->colHeaders[j] = NULL;
    }

    return matrix;
}

// 销毁稀疏矩阵
void destroySparseMatrix(SparseMatrix* matrix) {
    if (matrix == NULL) {
        return;
    }

    // 释放所有节点内存
    for (int i = 1; i <= matrix->rows; i++) {
        MatrixNode* current = matrix->rowHeaders[i];
        while (current != NULL) {
            MatrixNode* temp = current;
            current = current->right;
            free(temp);
        }
    }

    // 释放行表头节点数组
    free(matrix->rowHeaders);

    // 释放列表头节点数组
    free(matrix->colHeaders);

    // 释放稀疏矩阵结构
    free(matrix);
}

// 插入元素
void insertElement(SparseMatrix* matrix, int row, int col, int value) {
    if (row <= 0 || row > matrix->rows || col <= 0 || col > matrix->cols) {
        printf("Invalid position!\n");
        return;
    }

    // 创建新节点
    MatrixNode* newNode = (MatrixNode*)malloc(sizeof(MatrixNode));
    newNode->row = row;
    newNode->col = col;
    newNode->value = value;
    newNode->right = NULL;
    newNode->down = NULL;

    // 插入到行链表
    if (matrix->rowHeaders[row] == NULL || matrix->rowHeaders[row]->col > col) {
        // 插入到行链表的头部
        newNode->right = matrix->rowHeaders[row];
        matrix->rowHeaders[row] = newNode;
    } else {
        MatrixNode* current = matrix->rowHeaders[row];
        while (current->right != NULL && current->right->col < col) {
            current = current->right;
        }
        newNode->right = current->right;
        current->right = newNode;
    }

    // 插入到列链表
    if (matrix->colHeaders[col] == NULL || matrix->colHeaders[col]->row > row) {
        // 插入到列链表的头部
        newNode->down = matrix->colHeaders[col];
        matrix->colHeaders[col] = newNode;
    } else {
        MatrixNode* current = matrix->colHeaders[col];
        while (current->down != NULL && current->down->row < row) {
            current = current->down;
        }
        newNode->down = current->down;
        current->down = newNode;
    }
}

// 打印稀疏矩阵
void printSparseMatrix(SparseMatrix* matrix) {
    for (int i = 1; i <= matrix->rows; i++) {
        MatrixNode* current = matrix->rowHeaders[i];
        for (int j = 1; j <= matrix->cols; j++) {
            if (current != NULL && current->col == j) {
                printf("%d ", current->value);
                current = current->right;
            } else {
                printf("0 ");
            }
        }
        printf("\n");
    }
}

// 矩阵加法
SparseMatrix* matrixAddition(SparseMatrix* matrix1, SparseMatrix* matrix2) {
    if (matrix1->rows != matrix2->rows || matrix1->cols != matrix2->cols) {
        printf("Matrix dimensions do not match!\n");
        return NULL;
    }

    SparseMatrix* result = createSparseMatrix(matrix1->rows, matrix1->cols);

    for (int i = 1; i <= matrix1->rows; i++) {
        MatrixNode* node1 = matrix1->rowHeaders[i];
        MatrixNode* node2 = matrix2->rowHeaders[i];

        while (node1 != NULL && node2 != NULL) {
            if (node1->col == node2->col) {
                int sum = node1->value + node2->value;
                insertElement(result, node1->row, node1->col, sum);
                node1 = node1->right;
                node2 = node2->right;
            } else if (node1->col < node2->col) {
                insertElement(result, node1->row, node1->col, node1->value);
                node1 = node1->right;
            } else {
                insertElement(result, node2->row, node2->col, node2->value);
                node2 = node2->right;
            }
        }

        while (node1 != NULL) {
            insertElement(result, node1->row, node1->col, node1->value);
            node1 = node1->right;
        }

        while (node2 != NULL) {
            insertElement(result, node2->row, node2->col, node2->value);
            node2 = node2->right;
        }
    }

    return result;
}

// 矩阵乘法
SparseMatrix* matrixMultiplication(SparseMatrix* matrix1, SparseMatrix* matrix2) {
    if (matrix1->cols != matrix2->rows) {
        printf("Matrix dimensions do not match!\n");
        return NULL;
    }

    SparseMatrix* result = createSparseMatrix(matrix1->rows, matrix2->cols);

    for (int i = 1; i <= matrix1->rows; i++) {
        for (int j = 1; j <= matrix2->cols; j++) {
            int sum = 0;

            MatrixNode* node1 = matrix1->rowHeaders[i];
            MatrixNode* node2 = matrix2->colHeaders[j];

            while (node1 != NULL && node2 != NULL) {
                if (node1->col == node2->row) {
                    sum += node1->value * node2->value;
                    node1 = node1->right;
                    node2 = node2->down;
                } else if (node1->col < node2->row) {
                    node1 = node1->right;
                } else {
                    node2 = node2->down;
                }
            }

            if (sum != 0) {
                insertElement(result, i, j, sum);
            }
        }
    }

    return result;
}

// 矩阵转置
SparseMatrix* matrixTranspose(SparseMatrix* matrix) {
    SparseMatrix* result = createSparseMatrix(matrix->cols, matrix->rows);

    for (int i = 1; i <= matrix->rows; i++) {
        MatrixNode* current = matrix->rowHeaders[i];
        while (current != NULL) {
            insertElement(result, current->col, current->row, current->value);
            current = current->right;
        }
    }

    return result;
}

int main() {
    // 创建一个5x5的稀疏矩阵
    SparseMatrix* matrix1 = createSparseMatrix(5, 5);

    // 插入元素
    insertElement(matrix1, 1, 3, 5);
    insertElement(matrix1, 1, 4, 2);
    insertElement(matrix1, 5, 2, 1);
    insertElement(matrix1, 5, 1, 8);
    insertElement(matrix1, 5, 5, 7);

    // 打印稀疏矩阵
    printf("\nSparse Matrix 1:\n");
    printSparseMatrix(matrix1);

    // 创建另一个5x3的稀疏矩阵
    SparseMatrix* matrix2 = createSparseMatrix(5, 3);

    // 插入元素
    insertElement(matrix2, 1, 1, 1);
    insertElement(matrix2, 1, 3, 2);
    insertElement(matrix2, 2, 2, 3);
    insertElement(matrix2, 3, 1, 4);
    insertElement(matrix2, 3, 3, 5);

    // 打印稀疏矩阵
    printf("\nSparse Matrix 2:\n");
    printSparseMatrix(matrix2);

    // 矩阵加法
    SparseMatrix* additionResult = matrixAddition(matrix1, matrix1);
    printf("\nMatrix Addition Result:\n");
    printSparseMatrix(additionResult);

    // 矩阵乘法
    SparseMatrix* multiplicationResult = matrixMultiplication(matrix1, matrix2);
    printf("\nMatrix Multiplication Result:\n");
    printSparseMatrix(multiplicationResult);

    // 矩阵转置
    SparseMatrix* transposeResult = matrixTranspose(matrix1);
    printf("\nMatrix Transpose Result:\n");
    printSparseMatrix(transposeResult);

    // 销毁稀疏矩阵
    destroySparseMatrix(matrix1);
    destroySparseMatrix(matrix2);
    destroySparseMatrix(additionResult);
    destroySparseMatrix(multiplicationResult);
    destroySparseMatrix(transposeResult);

    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1147248.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

linux 系统编程复习07-信号

linux 系统编程复习07-信号

1 复习目标 了解信号中的基本概念熟练使用信号相关的函数参考文档使用信号集操作相关函数熟练使用信号捕捉函数signal熟练使用信号捕捉函数sigaction熟练掌握使用信号完成子进程的回收 信号介绍 信号的概念 信号是信息的载体&#xff0c;Linux/UNIX 环境下&#xff0c;古老…
阅读更多...
【C语言】优化通讯录管理系统

【C语言】优化通讯录管理系统

大家好&#xff0c;我是苏貝&#xff0c;本篇博客带大家优化上一篇的通讯录&#xff0c;如果你觉得我写的还不错的话&#xff0c;可以给我一个赞&#x1f44d;吗&#xff0c;感谢❤️ 目录 一. 前言二. 动态通讯录2.1 通讯录结构体2.2 初始化通讯录2.3 增加联系人2.4 销毁通讯…
阅读更多...
【需要理解】80 单词搜索

【需要理解】80 单词搜索

单词搜索 题解1 回溯&#xff08;需要改变起点&#xff09; 给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 单词必须按照字母顺序&#xff0c;通过相邻的单元格内…
阅读更多...
数据结构——线性表①（顺序表）

数据结构——线性表①（顺序表）

一、线性表定义 线性表是一种数据结构&#xff0c;它是由n个具有相同数据类型的数据元素a1,a2,…,an组成的有限序列。 其中&#xff0c;除第一个元素a1外&#xff0c;每一个元素有且只有一个直接前驱元素&#xff0c;除了最后一个元素an外&#xff0c;每一个元素有且只有一个…
阅读更多...
IDEA 如何运行 SpringBoot 项目

IDEA 如何运行 SpringBoot 项目

步骤一&#xff1a;配置 Maven 第一步&#xff1a;用 IDEA 打开项目&#xff0c;准备配置 maven 环境 &#xff0c;当然如果本地没有提前配置好 maven&#xff0c;就用 IDEA 默认的配置即可 配置 maven 步骤 情况 1&#xff1a;如果本地没有配置过 maven&#xff0c;可以保持如…
阅读更多...
【Spring】IOC容器与Bean的常用属性配置

【Spring】IOC容器与Bean的常用属性配置

文章目录 1.前言2.IOC容器2.1 BeanFactory 容器2.2 ApplicationContext 容器 3.Bean的常用属性配置4. 总结 1.前言 在之前的文章-IOC的快速入门中讲过Bean这个概念. 本来就来介绍容器与Bean的常用属性配置 在Spring框架中&#xff0c;Bean指的是被Spring加载生成出来的对象。 …
阅读更多...
ubuntu 18.04 编译安装flexpart 10.4（2023年） —— 筑梦之路

ubuntu 18.04 编译安装flexpart 10.4（2023年） —— 筑梦之路

2023年10月29日 环境说明 操作系统版本&#xff1a;ubuntu 18.04 python版本&#xff1a;3.6.9 gcc版本&#xff1a;7.5.0 编译安装路径&#xff1a;/usr/local cmake: 3.10.2 所需要的源码包我已经打包放到我的资源。 2021年1月份已经写过一篇Ubuntu 编译安装的帖子F…
阅读更多...
Android OpenGL ES 2.0入门实践

Android OpenGL ES 2.0入门实践

本文既然是入门实践&#xff0c;就先从简单的2D图形开始&#xff0c;首先&#xff0c;参考两篇官方文档搭建个框架&#xff0c;便于写OpenGL ES相关的代码&#xff1a;构建 OpenGL ES 环境、OpenGL ES 2.0 及更高版本中的投影和相机视图。 先上代码&#xff0c;代码效果如下图…
阅读更多...
MQ——进阶

MQ——进阶

文章目录 消息可靠性生产者消息确认消息持久化消费者确认演示none模式演示auto模式 失败重试机制本地重试失败策略 死信交换机初始死信交换机TTL延迟队列安装DelayExchange插件使用DelayExchange 惰性队列消息堆积问题惰性队列 MQ集群集群分类普通集群镜像模式镜像模式的配置 仲…
阅读更多...
私有云：【6】VCenter安装SqlServer

私有云：【6】VCenter安装SqlServer

私有云&#xff1a;【6】VCenter安装SqlServer 1、VCenter安装SqlServer1.1、通过模板创建虚拟机1.2、安装sqlserver服务 2、搭建sqlserver群集2.1、安装群集功能2.2、在ad域服务器创建共享文件夹&#xff0c;供集群选举使用 3、创建故障转移群集【只需安装一台即可】3.1、创建…
阅读更多...
操作系统 --- 存储器管理

操作系统 --- 存储器管理

一、简答题 1.存储器管理的基本任务&#xff0c;是为多道程序的并发执行提供良好的存储器环境。请问好的存储器环境”应包含哪几个方面&#xff1f; 答&#xff1a; 2.内存保护是否可以完全由软件实现&#xff1f;为什么&#xff1f; 答&#xff1a;内存保护的主要任务是确保每…
阅读更多...
LeetCode热题100——双指针

LeetCode热题100——双指针

双指针 1.移动零2.盛最多水的容器3.三数之和 1.移动零 给定一个数组 nums&#xff0c;编写一个函数将所有 0 移动到数组的末尾&#xff0c;同时保持非零元素的相对顺序。 // 题解&#xff1a;使用双指针&#xff0c;其中快指针指向非零元素&#xff0c;慢指针指向首个零元素下…
阅读更多...
msvcp120.dll怎么修复，五种方法教你如何修复msvcp120.dll文件

msvcp120.dll怎么修复，五种方法教你如何修复msvcp120.dll文件

在运行软件时&#xff0c;我们常常会遇到一些错误提示&#xff0c;其中之一就是“由于找不到msvcp120.dll无法继续执行代码”。这个错误通常发生在使用Microsoft Visual C 2013编译的程序运行时。本文将介绍5种修复这个问题的方法&#xff0c;帮助各位解决这个困扰。 方法一、使…
阅读更多...
如何使用批量重命名的方法替换重复文件名内容

如何使用批量重命名的方法替换重复文件名内容

在文件管理过程中&#xff0c;我们有时会遇到文件名中包含相同部分内容的情况&#xff0c;这不仅会使文件显得混乱&#xff0c;而且还会给文件检索和使用带来不便。为了解决这个问题&#xff0c;我们可以使用云炫文件管理器批量重命名进行批量替换。下面是如何使用这种方法进行…
阅读更多...
RT-Thread入门

RT-Thread入门

1、初识RT-Thread RT-Thread&#xff0c;全称是Real Time-Thread&#xff0c;即嵌入式实时多线程操作系统。其基本属性之一是支持多任务&#xff0c;但是允许多任务同时运行&#xff0c;但是并不是意味着处理器在同一时刻真的执行了多个任务。实际上&#xff0c;一个处理器核心…
阅读更多...
mac 安装homebrew ,golang

mac 安装homebrew ,golang

mac 安装homebrew ,golang 安装homebrew安装golang选择 apple arm 版本安装配置环境变量 安装homebrew /bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)"回车执行指令后&#xff0c;根据提示操作。具体包括以下提示操作&am…
阅读更多...
深度学习（4）---生成式对抗网络(GAN)

深度学习（4）---生成式对抗网络(GAN)

文章目录 一、原理讲述1.1 概念讲解1.2 生成模型和判别模型 二、训练过程2.1 训练原理2.2 损失函数 三、应用 一、原理讲述 1.1 概念讲解 1. 生成式对抗网络&#xff08;Generative Adversarial Network&#xff0c;GAN&#xff09;是一种深度学习模型&#xff0c;是近年来复杂…
阅读更多...
vue vant van-uploader使用compressorjs解决拍照上传的图片被旋转 90 度方法，图片压缩上传

vue vant van-uploader使用compressorjs解决拍照上传的图片被旋转 90 度方法，图片压缩上传

vue vant van-uploader使用compressorjs解决拍照上传的图片被旋转 90 度方法&#xff0c;图片压缩上传_van-uploader 拍照上传服务器后图片翻转-CSDN博客文章浏览阅读3.2k次&#xff0c;点赞4次&#xff0c;收藏6次。van-uploader使用compressorjs解决拍照上传的图片被旋转 90 …
阅读更多...
游戏找不到x3daudio1_7.dll无法继续执行的解决方法，快速解决dll问题

游戏找不到x3daudio1_7.dll无法继续执行的解决方法，快速解决dll问题

x3daudio1_7.dll是一个音频处理库&#xff0c;主要用于实现三维音频渲染。它包含了微软的XAudio2音频API&#xff0c;该API被许多游戏和应用程序用于实现高质量的音频效果。这个库文件主要处理音频的空间定位、响度均衡以及多通道音频输出等功能。在游戏中&#xff0c;它可以为…
阅读更多...
08 MIT线性代数-求解Ax=b：可解性与结构Complete Solution of Ax=b

08 MIT线性代数-求解Ax=b：可解性与结构Complete Solution of Ax=b

1. 可解的条件 Solvability conditions on b 检验Axb是否可解的方法是对增广矩阵进行行消元。如果矩阵A的行被完全消去的话&#xff0c;则对应的b的分量也要得0 两条关于b的限制条件(等价) 1. if a comb. of rows of A gives zero row, then same comb. of enties of b must …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023