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

news2024/11/28 20:34:42

文章目录

  • 4.2.1 矩阵的数组表示
  • 4.2.2 特殊矩阵的压缩存储
    • a. 对角矩阵的压缩存储
    • b~c. 三角、对称矩阵的压缩存储
    • d. 稀疏矩阵的压缩存储——三元组表
    • 4.2.3三元组表的转置、加法、乘法、操作
    • 4.2.4十字链表
      • 0. 十字链表结构
      • 1. 创建
      • 2. 销毁
      • 3. 插入
      • 4. 打印矩阵形式
      • 5. 按行打印
      • 6.按列打印
      • 7. 主函数
      • 8. 代码整合

4.2.1 矩阵的数组表示

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

4.2.2 特殊矩阵的压缩存储

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

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

a. 对角矩阵的压缩存储

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

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

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

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

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

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

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

4.2.4十字链表

  十字链表（Cross-linked List）是一种用于表示稀疏矩阵的数据结构。稀疏矩阵是指大部分元素为零的矩阵，而十字链表可以有效地存储和操作这种类型的矩阵。在稀疏矩阵的十字链表中，每个非零元素都由一个节点表示。节点包含了几个字段：

  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. 十字链表结构

// 定义矩阵节点结构
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;

left~up ……right~down

1. 创建

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;
}
  • 分配稀疏矩阵结构体的内存，并将行数和列数存储在结构体的相应字段中。
  • 分配行表头节点数组的内存，并将每个元素初始化为NULL。
  • 分配列表头节点数组的内存，并将每个元素初始化为NULL。
  • 返回指向创建的稀疏矩阵的指针。

2. 销毁

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);
}
  • 检查稀疏矩阵指针是否为NULL，如果是，则直接返回。
  • 释放所有节点的内存：
    • 遍历每一行，从第一行到最后一行：
      • 通过行表头节点数组获取当前行的行链表头节点。
      • 遍历行链表中的每个节点：
        • 释放当前节点的内存，并将当前节点指针移动到下一个节点。
    • 释放行表头节点数组的内存。
    • 遍历每一列，从第一列到最后一列：
      • 通过列表头节点数组获取当前列的列链表头节点。
      • 遍历列链表中的每个节点：
        • 释放当前节点的内存，并将当前节点指针移动到下一个节点。
    • 释放列表头节点数组的内存。
  • 释放稀疏矩阵结构体的内存。

3. 插入

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

4. 打印矩阵形式

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");
    }
}
  • 从第一行开始遍历稀疏矩阵的每一行：
    • 通过行表头节点数组获取当前行的行链表头节点。
    • 遍历当前行的每一列，从第一列到最后一列：
      • 如果当前节点存在且与当前列匹配，则打印节点的值。
      • 否则，打印0。
    • 打印换行符。

5. 按行打印

void printRowNodes(SparseMatrix* matrix) {
    printf("Row Nodes:\n");
    for (int i = 1; i <= matrix->rows; i++) {
        printf("Row %d: ", i);
        MatrixNode* current = matrix->rowHeaders[i];
        while (current != NULL) {
            printf("(%d, %d, %d) ", current->row, current->col, current->value);
            current = current->right;
        }
        printf("\n");
    }
}
  • 从第一行开始遍历稀疏矩阵的每一行：
    • 打印当前行的行号。
    • 通过行表头节点数组获取当前行的行链表头节点。
    • 遍历当前行的行链表，打印每个节点的行、列和值。
    • 打印换行符。

6.按列打印

void printColumnNodes(SparseMatrix* matrix) {
    printf("Column Nodes:\n");
    for (int j = 1; j <= matrix->cols; j++) {
        printf("Column %d: ", j);
        MatrixNode* current = matrix->colHeaders[j];
        while (current != NULL) {
            printf("(%d, %d, %d) ", current->row, current->col, current->value);
            current = current->down;
        }
        printf("\n");
    }
}
  • 与行打印等价

7. 主函数

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

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

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

    // 输出每行节点
    printRowNodes(matrix);

    // 输出每列节点
    printColumnNodes(matrix);

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

    return 0;
}

在这里插入图片描述

8. 代码整合

#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");
    }
}

// 输出每行节点
void printRowNodes(SparseMatrix* matrix) {
    printf("Row Nodes:\n");
    for (int i = 1; i <= matrix->rows; i++) {
        printf("Row %d: ", i);
        MatrixNode* current = matrix->rowHeaders[i];
        while (current != NULL) {
            printf("(%d, %d, %d) ", current->row, current->col, current->value);
            current = current->right;
        }
        printf("\n");
    }
}

// 输出每列节点
void printColumnNodes(SparseMatrix* matrix) {
    printf("Column Nodes:\n");
    for (int j = 1; j <= matrix->cols; j++) {
        printf("Column %d: ", j);
        MatrixNode* current = matrix->colHeaders[j];
        while (current != NULL) {
            printf("(%d, %d, %d) ", current->row, current->col, current->value);
            current = current->down;
        }
        printf("\n");
    }
}

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

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

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

    // 输出每行节点
    printRowNodes(matrix);

    // 输出每列节点
    printColumnNodes(matrix);

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

    return 0;
}

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

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

相关文章

京东平台数据分析（京东销量）：2023年9月京东吸尘器行业品牌销售排行榜

京东平台数据分析（京东销量）：2023年9月京东吸尘器行业品牌销售排行榜

鲸参谋监测的京东平台9月份吸尘器市场销售数据已出炉&#xff01; 根据鲸参谋电商数据分析平台的相关数据显示&#xff0c;今年9月&#xff0c;京东吸尘器的销量为19万&#xff0c;环比下滑约12%&#xff0c;同比下滑约25%&#xff1b;销售额为1.2亿&#xff0c;环比下滑约11%&…
阅读更多...
刀具磨损状态识别（Python代码，MSCNN_LSTM_Attention模型，初期磨损、正常磨损和急剧磨损分类，解压缩直接运行）

刀具磨损状态识别（Python代码，MSCNN_LSTM_Attention模型，初期磨损、正常磨损和急剧磨损分类，解压缩直接运行）

1.运行效果&#xff1a;刀具磨损状态识别&#xff08;Python代码&#xff0c;MSCNN_LSTM_Attention模型&#xff0c;初期磨损、正常磨损和急剧磨损&#xff09;_哔哩哔哩_bilibili 环境库&#xff1a; NumPy 版本: 1.19.4 Pandas 版本: 0.23.4 Matplotlib 版本: 2.2.3 Keras …
阅读更多...
【Qt之控件QTreeView】设置单元格高度、设置图标尺寸

【Qt之控件QTreeView】设置单元格高度、设置图标尺寸

设置列宽 设置高度 自定义代理 继承QItemDelegate&#xff0c;实现sizeHint ()方法&#xff0c;设置自定义委托。 class itemDelegate : public QItemDelegate {Q_OBJECTpublic:explicit itemDelegate(QObject *parent 0) : QItemDelegate(parent){}~itemDelegate(){}virtua…
阅读更多...
策略路由和路由策略

策略路由和路由策略

目录 策略路由 路由策略 策略路由和路由策略 策略路由 Step1:配置ACL&#xff0c;匹配流量 acl number 2010 rule 10 permit source 192.168.10.0 0.0.0.255 acl number 2020 rule 10 permit source 192.168.20.0 0.0.0.255 Step2:流分类traffic classifier jiaoxue //匹配…
阅读更多...
Navicat for MySQL 视图创建使用方法

Navicat for MySQL 视图创建使用方法

创建视图步骤&#xff1a; 点击新建&#xff1b;选择视图&#xff1b;点击视图创建工具&#xff1b;可以在左侧拖拽表到工作区&#xff1b;选择表字段进行连线
阅读更多...
二维码智慧门牌管理系统升级，解决地址要素挂接难题！

二维码智慧门牌管理系统升级，解决地址要素挂接难题！

文章目录 前言一、传统问题和新解决方案二、多样化应用三、实际案例 前言 随着科技的不断发展&#xff0c;智能化管理已经深入到各行各业。在地址要素采集过程中&#xff0c;如何实现要素之间的挂接关系&#xff0c;是智慧门牌管理系统面临的重要挑战。本文将为您揭秘一种升级…
阅读更多...
【错误解决方案】ModuleNotFoundError: No module named ‘cPickle‘

【错误解决方案】ModuleNotFoundError: No module named ‘cPickle‘

1. 错误提示 在python程序中试图导入一个名为cPickle的模块&#xff0c;但Python提示找不到这个模块。 错误提示&#xff1a;ModuleNotFoundError: No module named cPickle 2. 解决方案 实际上&#xff0c;cPickle是Python的pickle模块的一个C语言实现&#xff0c;通常用于…
阅读更多...
【ROS入门】机器人导航（仿真）——导航实现

【ROS入门】机器人导航（仿真）——导航实现

文章结构 建图 SLAM编写gmapping节点相关launch文件执行 地图服务 map_server地图保存节点 map_server地图服务 map_server 定位 amcl编写amcl节点相关的launch文件编写测试launch文件执行 路径规划 move_basemove_base与代价地图碰撞算法 move_base使用launch文件配置文件laun…
阅读更多...
Selenium自动测试框架

Selenium自动测试框架

selenium3 selenium元素的定位css 选择器Xpath 操作测试对象 API添加等待浏览器的操作键盘操作鼠标操作定位一组元素下拉框弹窗上传文件 <dependencies><!-- https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-java --><dependency><…
阅读更多...
phar反序列化学习

phar反序列化学习

PHP反序列化常见的是使用unserilize()进行反序列化&#xff0c;除此之外还有其它的反序列化方法&#xff0c;不需要用到unserilize()。就是用到phar反序列化。 Phar phar文件 Phar是将php文件打包而成的一种压缩文档&#xff0c;类似于Java中的jar包。它有一个特性就是phar文…
阅读更多...
2024级199管理类联考之写作

2024级199管理类联考之写作

小作文(论证有效性分析-600字/30分/20-25分钟) 核心原理 找到明显的论证逻辑错误(找到4个即可得16分),然后分析前提推不出结论(14分)(反驳别人) 论证指的是前提推结论 前提引词&#xff1a;因为结论引词&#xff1a;所以,因此,由此可得等有些论证没有明显的引词,需要自行判断怎…
阅读更多...
QT webengine显示HTML简单示例

QT webengine显示HTML简单示例

文章目录 参考示例1TestWebenqine.promainwindow.hmainwindow.cppmain.cpp效果 示例2 (使用setDevToolsPage函数)main.cpp效果 参考 QT webengine显示HTML简单示例 示例1 编译器 : Desktop Qt 5.15.2 MSVC2019 64bit编辑器: QtCreator代码: TestWebenqine.pro # TestWeben…
阅读更多...
C语言char的取值范围以及溢出情况

C语言char的取值范围以及溢出情况

char 的取值范围 有符号&#xff1a; 1111 1111 ~ 1000 0000 — 0000 0000 ~ 0111 1111 -127 ~ -0 0 ~ 127 -128 ~ 127&#xff08;因为不需要两个 0 所以给负值增加了一位&#xff09; char 的溢出情况
阅读更多...
C语言其它进制转十进制

C语言其它进制转十进制

权值法介绍 权值法&#xff1a; 主要功能为将 X 进制数据转为十进制的数据&#xff0c;具体流程如下&#xff1a; 将 X 进制中的每一位上的 基数 * 位权&#xff0c;再累加 基数&#xff1a;X 进制中每一位的数码个数 位权&#xff1a;X 进制每一位上对应的权值 二进制转十进…
阅读更多...
MyString字符串类

MyString字符串类

MyString字符串类 包括&#xff1a;有参构造、拷贝构造、移动构造、析构、拷贝赋值和移动赋值。 MyString.h文件 #ifndef MYSTRING_H #define MYSTRING_H#include <iostream> using namespace std;class MyString {private:char* str;unsigned int MaxSize;unsigned i…
阅读更多...
C语言 定义一个函数,并调用,该函数中完成百文百鸡问题

C语言 定义一个函数,并调用,该函数中完成百文百鸡问题

#include<stdio.h> int main(int argc, char const *argv[]) {int num 0;for (int i 0; i < 33; i){for (int j 0; j < 50; j){int x 100 - i - j;if(3*i2*jx/3 100 && x%3 0){printf("&#x1f413;有%d只,母鸡有%d只,小鸡有%d只\n",i,j,…
阅读更多...
深度学习之基于yolov8的安全帽检测系统

深度学习之基于yolov8的安全帽检测系统

欢迎大家点赞、收藏、关注、评论啦 &#xff0c;由于篇幅有限&#xff0c;只展示了部分核心代码。 文章目录 一项目简介 二、功能三、基于yolov8的安全帽检测系统四. 总结 一项目简介 在企业作业和工地施工过程中&#xff0c;安全永远高于一切。众所周知&#xff0c;工人在进入…
阅读更多...
【C++】STL容器——list类的使用指南(含代码演示)（13）

【C++】STL容器——list类的使用指南(含代码演示)（13）

前言 大家好吖&#xff0c;欢迎来到 YY 滴C系列 &#xff0c;热烈欢迎&#xff01; 本章主要内容面向接触过C的老铁 主要内容含&#xff1a; 欢迎订阅 YY滴C专栏&#xff01;更多干货持续更新&#xff01;以下是传送门&#xff01; 目录 一、list 类——基本介绍二、list 类——…
阅读更多...
僵尸网络｜让人防不胜防的内部网络安全问题，作为企业IT不得不了解的基础安全

僵尸网络｜让人防不胜防的内部网络安全问题，作为企业IT不得不了解的基础安全

在当今数字化世界中&#xff0c;僵尸网络是一种令人不安的存在。它不是一种具体的物理实体&#xff0c;而是一种由恶意软件控制的虚拟网络。这个网络由成百上千&#xff0c;甚至数百万台计算机组成&#xff0c;这些计算机往往被感染&#xff0c;成为攻击者的"僵尸"&a…
阅读更多...
基于深度学习的水果识别系统

基于深度学习的水果识别系统

收藏和点赞&#xff0c;您的关注是我创作的动力 文章目录 概要 一、 水果识别的实验结果分析3.1 实验环境3.2 水果数据集 二、水果识别的界面展示结 论目录 概要 本文详细地介绍了深度学习算法卷积神经网络&#xff08;CNN&#xff09;的发展状况。主要介绍了卷积神经网络的几…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023