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

news2024/12/23 11:47:07

文章目录

  • 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. 插入

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;
    }
}
  • 检查行数和列数是否在有效范围内，如果不是，则打印错误消息并返回。
  • 创建一个新的节点，并将行、列和值存储在节点的相应字段中。
  • 在行链表中插入节点：
    • 如果当前行的行链表为空，或者当前行的行链表头节点的列大于要插入的列：
      • 将要插入的节点的右指针指向当前行的行链表头节点。
      • 将当前行的行链表头节点更新为要插入的节点。
    • 否则，遍历当前行的行链表，直到找到插入位置：
      • 将要插入的节点的右指针指向当前节点的右指针。
      • 将当前节点的右指针指向要插入的节点。
  • 在列链表中插入节点：
    • 如果当前列的列链表为空，或者当前列的列链表头节点的行大于要插入的行：
      • 将要插入的节点的下指针指向当前列的列链表头节点。
      • 将当前列的列链表头节点更新为要插入的节点。
    • 否则，遍历当前列的列链表，直到找到插入位置：
      • 将要插入的节点的下指针指向当前节点的下指针。
      • 将当前节点的下指针指向要插入的节点。

2. 查找

MatrixNode* findElement(SparseMatrix* matrix, int row, int col) {
    if (row <= 0 || row > matrix->rows || col <= 0 || col > matrix->cols) {
        printf("Invalid position!\n");
        return NULL;
    }

    MatrixNode* current = matrix->rowHeaders[row];
    while (current != NULL && current->col != col) {
        current = current->right;
    }

    return current;
}
  • 检查行数和列数是否在有效范围内，如果不是，则打印错误消息并返回NULL。
  • 从第一行开始遍历稀疏矩阵的每一行：
    • 通过行表头节点数组获取当前行的行链表头节点。
    • 遍历当前行的行链表，直到找到要查找的节点或遍历完整个链表。
  • 如果找到要查找的节点，则返回节点的指针；否则，返回NULL。

3. 删除

void deleteElement(SparseMatrix* matrix, int row, int col) {
    if (row <= 0 || row > matrix->rows || col <= 0 || col > matrix->cols) {
        printf("Invalid position!\n");
        return;
    }

    // 在行链表中删除节点
    MatrixNode* current = matrix->rowHeaders[row];
    MatrixNode* prev = NULL;
    while (current != NULL && current->col != col) {
        prev = current;
        current = current->right;
    }
    if (current == NULL) {
        printf("Element not found!\n");
        return;
    }
    if (prev == NULL) {
        matrix->rowHeaders[row] = current->right;
    } else {
        prev->right = current->right;
    }

    // 在列链表中删除节点
    current = matrix->colHeaders[col];
    prev = NULL;
    while (current != NULL && current->row != row) {
        prev = current;
        current = current->down;
    }
    if (prev == NULL) {
        matrix->colHeaders[col] = current->down;
    } else {
        prev->down = current->down;
    }

    // 释放节点内存
    free(current);
}
  • 检查行数和列数是否在有效范围内，如果不是，则打印错误消息并返回。
  • 在行链表中查找要删除的节点：
    • 从当前行的行链表头节点开始遍历行链表，直到找到要删除的节点或遍历完整个链表。
  • 如果找到要删除的节点：
    • 如果要删除的节点是行链表的头节点：
      • 将当前行的行链表头节点更新为要删除的节点的右指针。
    • 否则，遍历行链表，直到找到要删除的节点的前一个节点：
      • 将前一个节点的右指针指向要删除的节点的右指针。
  • 在列链表中查找要删除的节点：
    • 从当前列的列链表头节点开始遍历列链表，直到找到要删除的节点或遍历完整个链表。
  • 如果找到要删除的节点：
    • 如果要删除的节点是列链表的头节点：
      • 将当前列的列链表头节点更新为要删除的节点的下指针。
    • 否则，遍历列链表，直到找到要删除的节点的前一个节点：
      • 将前一个节点的下指针指向要删除的节点的下指针。
  • 释放要删除的节点的内存。

4. 主函数

int main() {
    // 创建一个3x3的稀疏矩阵
    SparseMatrix* matrix = createSparseMatrix(6, 6);

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

    // 打印稀疏矩阵
    printf("Sparse Matrix:\n");
    printSparseMatrix(matrix);


    // 查找节点
    MatrixNode* node = findElement(matrix, 1, 4);
    if (node != NULL) {
        printf("\nFound node: (%d, %d, %d)\n", node->row, node->col, node->value);
    } else {
        printf("\nNode not found!\n");
    }
    // 删除节点
    deleteElement(matrix,5,5);
    printf("Sparse Matrix after deletion:\n");
    printSparseMatrix(matrix);

    // 销毁稀疏矩阵
    destroySparseMatrix(matrix);

    return 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 deleteElement(SparseMatrix* matrix, int row, int col) {
    if (row <= 0 || row > matrix->rows || col <= 0 || col > matrix->cols) {
        printf("Invalid position!\n");
        return;
    }

    // 在行链表中删除节点
    MatrixNode* current = matrix->rowHeaders[row];
    MatrixNode* prev = NULL;
    while (current != NULL && current->col != col) {
        prev = current;
        current = current->right;
    }
    if (current == NULL) {
        printf("Element not found!\n");
        return;
    }
    if (prev == NULL) {
        matrix->rowHeaders[row] = current->right;
    } else {
        prev->right = current->right;
    }

    // 在列链表中删除节点
    current = matrix->colHeaders[col];
    prev = NULL;
    while (current != NULL && current->row != row) {
        prev = current;
        current = current->down;
    }
    if (prev == NULL) {
        matrix->colHeaders[col] = current->down;
    } else {
        prev->down = current->down;
    }

    // 释放节点内存
    free(current);
}

// 查找节点
MatrixNode* findElement(SparseMatrix* matrix, int row, int col) {
    if (row <= 0 || row > matrix->rows || col <= 0 || col > matrix->cols) {
        printf("Invalid position!\n");
        return NULL;
    }

    MatrixNode* current = matrix->rowHeaders[row];
    while (current != NULL && current->col != col) {
        current = current->right;
    }

    return current;
}

// 打印稀疏矩阵
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");
    }
}


int main() {
    // 创建一个3x3的稀疏矩阵
    SparseMatrix* matrix = createSparseMatrix(6, 6);

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

    // 打印稀疏矩阵
    printf("Sparse Matrix:\n");
    printSparseMatrix(matrix);


    // 查找节点
    MatrixNode* node = findElement(matrix, 1, 4);
    if (node != NULL) {
        printf("\nFound node: (%d, %d, %d)\n", node->row, node->col, node->value);
    } else {
        printf("\nNode not found!\n");
    }
    // 删除节点
    deleteElement(matrix,5,5);
    printf("Sparse Matrix after deletion:\n");
    printSparseMatrix(matrix);

    // 销毁稀疏矩阵
    destroySparseMatrix(matrix);

    return 0;
}

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

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

相关文章

C++学习day--22 宏和结构体

C++学习day--22 宏和结构体

1、宏 1.1 为什么要使用宏 1、提高代码的可读性和可维护性 2、避免函数调用&#xff0c;提高程序效率 1.2 什么是宏 它是一种预处理器指令&#xff0c;在预编译阶段将宏名替换为后面的替换体 。 1.3 宏的定义 由三部分组成&#xff1a; #define WIDTH 960 三个部分分别是&…
阅读更多...
Python 作用域：局部作用域、全局作用域和使用 global 关键字

Python 作用域：局部作用域、全局作用域和使用 global 关键字

变量只在创建它的区域内可用。这被称为作用域。 局部作用域 在函数内部创建的变量属于该函数的局部作用域&#xff0c;并且只能在该函数内部使用。 示例&#xff1a;在函数内部创建的变量在该函数内部可用&#xff1a; def myfunc():x 300print(x)myfunc()函数内部的函数 …
阅读更多...
C++——类和对象(中)（2）尚未完结

C++——类和对象(中)（2）尚未完结

拷贝构造 概念 在现实生活中&#xff0c;可能存在一个与你一样的自己&#xff0c;我们称其为双胞胎。 那在创建对象时&#xff0c;可否创建一个与已存在对象一某一样的新对象呢? 拷贝构造函数: 只有单个形参&#xff0c;该形参是对本类类型对象的引用(一般常用const修饰)&…
阅读更多...
模块化编程

模块化编程

1、函数单独写在一个文件中.c&#xff0c;然后声明也写在一个文件中.h,在mian.c中引用 2、安装目录下面的文件夹用<>,在自己文件夹目录下就是"" 3、创建自己的&#xff08;先把函数放在c文件&#xff0c;再创建头h文件&#xff09;
阅读更多...
ruoyi-plus创建模块、自动生成代码

ruoyi-plus创建模块、自动生成代码

ruoyi-plus自动生成代码 1、创建模块 复制其他部分的resouce过来 修改yml文件 2 修改Nacos 2.1 修改数据库文件 复制其他数据库的链接 &#xff0c;改为自己新建的数据库名字 修改为自己要生成的数据库 新建数据库的yaml文件 3 重启docker的ruoyi-gen服务 docker re…
阅读更多...
数据结构【DS】B树

数据结构【DS】B树

m阶B树的核心特性: Q&#xff1a;根节点的子树数范围是多少&#xff1f;关键字数的范围是多少&#xff1f; A&#xff1a;根节点的子树数∈[2, m],关键字数∈[1, m-1]。 Q&#xff1a;其他结点的子树数范围是多少&#xff1f;关键字数范围是多少&#xff1f; Q&#xff1a;对任…
阅读更多...
SSD1306 oled显示屏的驱动SPI接口

SSD1306 oled显示屏的驱动SPI接口

有IIC接口 和SPI接口 还有8080,6080接口等 arduino SPI接口 直接使用u8g2库实现 //U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock*/ 13, /* data*/ 11, /* cs*/ 10, /* dc*/ 9, /* reset*/ 8); asrpro(SPI接口按下方修改&#xff0c;IIC接口官方有驱动&…
阅读更多...
环形链表（C++解法）

环形链表（C++解法）

题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#…
阅读更多...
Vmware下的虚拟机NAT连接后仍然木有网络

Vmware下的虚拟机NAT连接后仍然木有网络

问题描述 出现在主机能ping通&#xff0c;互联网ping不通的情况。 废话 假设已经设置了网络配置文件IPADDR。 那么&#xff0c;NAT后可以访问互联网的前提是&#xff1a;这个IPADDR的网段在Vmware软件设置的网段内。 解决 在Vmware虚拟网络设置选项卡中&#xff0c;进NAT配…
阅读更多...
10000字！图解机器学习特征工程

10000字！图解机器学习特征工程

文章目录 引言特征工程1.特征类型1.1 结构化 vs 非结构化数据1.2 定量 vs 定性数据 2.数据清洗2.1 数据对齐2.2 缺失值处理 原文链接&#xff1a;https://www.showmeai.tech/article-detail/208 作者&#xff1a;showmeAI 引言 上图为大家熟悉的机器学习建模流程图&#xff0c;…
阅读更多...
TYWZOJ 礼品配对包装 题解

TYWZOJ 礼品配对包装 题解

文章目录 题目描述输入格式输出格式样例样例输入样例输出 数据范围与提示思路与部分实现完整代码 题目描述 爱与愁大神在这家目标店买了 2 x 2x 2x 份礼物&#xff0c;打算分给班级同学。其中有 x x x 份黑礼品&#xff0c; x x x 份白礼品&#xff0c; 2 x 2 2x2 2x2 个空…
阅读更多...
计网小题题库整理第一轮（面向期末基础）（3）

计网小题题库整理第一轮（面向期末基础）（3）

基础选择题的最后一章更新&#xff0c;看完期末75至少没问题~ 前情提要&#xff1a; 计网小题题库整理第一轮&#xff08;12期&#xff09; 一.选择题 1、 目前,最流行的以太网组网的拓扑结构是&#xff08; C &#xff09;。 A&#xff09; 总线结构 B&#xff09; 环…
阅读更多...
如何能够在发现问题和提问的时候一并带出自己的解决方案

如何能够在发现问题和提问的时候一并带出自己的解决方案

1. 充分理解问题&#xff1a; 在提出问题之前&#xff0c;确保你已经完全理解了问题的本质。从不同的角度分析问题&#xff0c;确保没有遗漏任何重要的信息或者上下文。 2. 进行自我调查和研究&#xff1a; 在向他人寻求帮助之前&#xff0c;尝试自己解决问题。利用网络资源…
阅读更多...
Go学习第十三章——Gin（入门与路由）

Go学习第十三章——Gin（入门与路由）

Go web框架——Gin&#xff08;入门与路由&#xff09; 1 Gin框架介绍1.1 基础介绍1.2 安装Gin1.3 快速使用 2 路由2.1 基本路由GET请求POST请求 2.2 路由参数2.3 路由分组基本分组带中间件的分组 2.4 重定向 1 Gin框架介绍 github链接&#xff1a;https://github.com/gin-gon…
阅读更多...
从零开始搭建Prometheus+grafana服务器组件监控系统

从零开始搭建Prometheus+grafana服务器组件监控系统

服务器及相关组件监控 本文档主要记录了常用企业级服务器及各种组件的监控手段和监控部署方案&#xff0c;使企业可以实时感知服务器组件的健康状态&#xff0c;并在服务器或组件出现异常时及时做出反应。 本方案采用的Prometheusgrafana的方式实现对服务器及各种组件的监控&am…
阅读更多...
【前端】NodeJS核心知识点整理

【前端】NodeJS核心知识点整理

1.Node.js入门案例 1.1.什么是Node.js JS是脚本语言&#xff0c;脚本语言都需要一个解析器才能运行。对于写在HTML页面里的JS&#xff0c;浏览器充当了解析器的角色。而对于需要独立运行的JS&#xff0c;NodeJS就是一个解析器。 每一种解析器都是一个运行环境&#xff0c;不但…
阅读更多...
C/C++数据结构之深入了解线性表：顺序表、单链表、循环链表和双向链表

C/C++数据结构之深入了解线性表：顺序表、单链表、循环链表和双向链表

线性表是一种基本的数据结构&#xff0c;它在计算机科学中起着至关重要的作用。线性表用于存储一系列具有相同数据类型的元素&#xff0c;这些元素之间存在顺序关系。在C/C中&#xff0c;我们可以使用各种方式来实现线性表&#xff0c;其中包括顺序表、单链表、循环链表和双向链…
阅读更多...
基于白鲸优化算法BWO优化的VMD-KELM光伏发电短期功率预测MATLAB代码（含详细算法介绍）

基于白鲸优化算法BWO优化的VMD-KELM光伏发电短期功率预测MATLAB代码（含详细算法介绍）

微❤关注“电气仔推送”获得资料&#xff08;专享优惠&#xff09; VMD适用于处理非线性和非平稳信号&#xff0c;例如振动信号、生物信号、地震信号、图像信号等。它在信号处理、振动分析、图像处理等领域有广泛的应用&#xff0c;特别是在提取信号中的隐含信息和去除噪声方面…
阅读更多...
无头浏览器自动化：Puppeteer 帮你释放效能 | 开源日报 No.64

无头浏览器自动化：Puppeteer 帮你释放效能 | 开源日报 No.64

facebook/react Stars: 209.5k License: MIT React是一个用于构建用户界面的JavaScript库。它具有以下优势和特点&#xff1a; 声明式&#xff1a;React使得创建交互式UI变得轻松。您可以为应用程序中的每个状态设计简单视图&#xff0c;当数据发生更改时&#xff0c;React会…
阅读更多...
Postman日常操作

Postman日常操作

一.Postman介绍 1.1第一个简单的demo 路特斯&#xff08;英国汽车品牌&#xff09;_百度百科 (baidu.com) 1.2 cookie 用postman测试需要登录权限的接口时&#xff0c;会被拦截&#xff0c;解决办法就是每次请求接口前&#xff0c;先执行登录&#xff0c;然后记住cookie或者to…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023