单链表的C/C++语言描述实现模板

已于 2023-02-12 13:12:01 修改
阅读量1.7k 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 链表 c++ c语言
于 2022-04-26 11:13:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62083249/article/details/124423365
版权

文章目录

前言

数据结构中单链表的C/C++语言描述实现模板，有详细的步骤解析及使用示例。

代码仓库

linkList.cpp

//头文件————————————————————
#include <iostream>
using namespace std;

//自定义数据类型————————————————————
typedef int ELEM_TYPE; //数据的（数据）类型 依据数据的实际类型定义

//结构体
//定义
//结点
typedef struct LNode
{
    ELEM_TYPE data;     //数据
    struct LNode *next; //指向直接后继结点的指针
} LNode;
// struct LNode：结构体数据类型的名称
//如创建一个结点的语句：struct LNode node;
//若结构体数据类型内存在指向该结构体的指针数据类型，则必须完整命名结构体数据类型的名称
//如结点结构体LNode内存在指向该结构体的指针数据类型next，则命名语句为：typedef struct LNode而不是typedef struct
// LNode：typedef给结构体数据类型起的别名，可简化语句
//如创建一个结点的语句：LNode node;
//结构体数据类型的名称和别名尽量一致，以方便记忆、使用

//函数声明————————————————————
void use_example();                                                  //使用示例
void create_list_head(LNode *&head, ELEM_TYPE value[], int count);   //创建  头插法
void create_list_tail(LNode *&head, ELEM_TYPE value[], int count);   //创建  尾插法
LNode *find_node(LNode *head, ELEM_TYPE elem);                       //按值查找
LNode *get_node(LNode *head, int i);                                 //按序查找
void insert_node(LNode *&head, int posi, LNode *node);               //插入  前插
void insert_node_exten(LNode *&head, int posi, LNode *node);         //插入  扩展：前插转后插
void delele_node(LNode *&head, int posi);                            //删除  前删
void delele_node_exten(LNode *&head, int posi);                      //删除  前删转后删
int get_length(LNode *head);                                         //获取表长
void clear_list(LNode *&head);                                       //清空
void merge_list_increase(LNode *head1, LNode *head2, LNode *&head3); //合并两递增表成递增表
void merge_list_reduce(LNode *head1, LNode *head2, LNode *&head3);   //合并两递增表成递减表

//主函数————————————————————
int main()
{
    use_example(); //使用示例

    return 0;
}

//函数定义————————————————————
//使用示例
void use_example()
{
    //创建
    struct LNode *head; //头指针，指向头结点或第一个结点
    //或LNode *head;
    //一般头指针变量名为链表表名    这里用head见明知意，表示是头指针

    ELEM_TYPE value[3]; //数据数组
    value[0] = 100;
    value[1] = 200;
    value[2] = 300;

    create_list_tail(head, value, 3); //创建    尾插法  元素在表中的排列：100，200，300

    //按值查找
    LNode *node; //结点指针

    node = find_node(head, 100); //按值查找

    cout << node->data << endl; //输出：100

    //按序查找
    node = get_node(head, 2); //按序查找

    cout << node->data << endl; //输出：200

    //插入  前插
    node = (LNode *)malloc(sizeof(LNode)); //创建新结点   结点指针指向新结点
    node->data = 400;                      //初始化新结点的数据域

    insert_node(head, 3, node); //插入 前插 元素在表中的排列：100，200，400，300

    //插入  扩展：前插转后插
    node = (LNode *)malloc(sizeof(LNode)); //创建新结点   结点指针指向新结点
    node->data = 500;                      //初始化新结点的数据域

    insert_node_exten(head, 3, node); //插入    扩展：前插转后插    元素在表中的排列：100，200，500，400，300

    LNode *p;       //移动结点指针
    p = head->next; //初始化移动结点指针 指向第一个结点（头结点的下一个结点）

    while (p != NULL) //遍历
    {
        cout << p->data << endl; //输出：100，200，500，400，300

        p = p->next; //移动结点指针
    }

    //删除  前删
    delele_node(head, 3); //删除  前删  元素在表中的排列：100，200，400，300

    //删除  前删转后删
    delele_node_exten(head, 3); //删除  前删转后删  元素在表中的排列：100，200，300

    p = head->next; //初始化移动结点指针 指向第一个结点（头结点的下一个结点）

    while (p != NULL) //遍历
    {
        cout << p->data << endl; //输出：100，200，300

        p = p->next; //移动结点指针
    }

    //获取表长
    int list_length = 0; //表长

    list_length = get_length(head);

    cout << list_length << endl; //输出：3

    //清空
    clear_list(head);

    list_length = get_length(head);

    cout << list_length << endl; //输出：0

    //合并两递增表成递增表
    struct LNode *head1; //递增表1的头指针，指向头结点或第一个结点

    ELEM_TYPE value1[3]; //数据数组1
    value1[0] = 100;
    value1[1] = 300;
    value1[2] = 500;

    create_list_tail(head1, value1, 3); //创建    尾插法  元素在表中的排列：100，300，500

    struct LNode *head2; //递增表2的头指针，指向头结点或第一个结点

    ELEM_TYPE value2[3]; //数据数组2
    value2[0] = 200;
    value2[1] = 400;
    value2[2] = 600;

    create_list_tail(head2, value2, 3); //创建    尾插法  元素在表中的排列：200，400，600

    struct LNode *head3; //新递增表的头指针，指向头结点或第一个结点

    merge_list_increase(head1, head2, head3); //合并两递增表成递增表

    p = head3->next;  //移动结点指针    指向新递增表的第一个结点
    while (p != NULL) //遍历
    {
        cout << p->data << endl; //输出：100，200，300，400，500，600

        p = p->next; //移动结点指针
    }

    //合并两递增表成递减少表
    create_list_tail(head1, value1, 3); //创建    尾插法  元素在表中的排列：100，300，500
    create_list_tail(head2, value2, 3); //创建    尾插法  元素在表中的排列：200，400，600
    clear_list(head3);                  //清空

    merge_list_reduce(head1, head2, head3); //合并两递增表成递减表

    p = head3->next;  //移动结点指针    指向新递减表的第一个结点
    while (p != NULL) //遍历
    {
        cout << p->data << endl; //输出：600，500，400，300，200，100

        p = p->next; //移动结点指针
    }

    return;
}

//函数定义————————————————————
//创建  头插法
//时间复杂度：O(n)
//注意：参数使用*&，指向指针的引用数据类型
//若只使用*，指针数据类型，在函数体中并未进行解引用调用修改*head的值，使用malloc()修改的是head的值
//所以是值拷贝，函数返回后数据丢失。地址拷贝需要引用数据类型的配合
void create_list_head(LNode *&head, ELEM_TYPE value[], int count) //参数：头指针，数据数组，数据数量
{
    head = (LNode *)malloc(sizeof(LNode)); //创建头结点，头指针指向头结点
    head->next = NULL;                     //初始化头结点的指针域

    LNode *node; //新结点指针

    for (int i = 0; i < count; i++) //循环创建链表
    {
        node = (LNode *)malloc(sizeof(LNode)); //创建新结点，新结点指针指向新结点
        node->data = value[i];                 //初始化新结点的数据域

        node->next = head->next; //初始化新结点的指针域
        head->next = node;
        //插入到链表的头结点和前一新结点之间
        //链表描述：头结点->当前新结点->前一新结点->...->空
        //若无头结点：head=node;
    }

    return;
}

//创建  尾插法
//时间复杂度：O(n)
void create_list_tail(LNode *&head, ELEM_TYPE value[], int count) //参数：头指针，数据数组，数据数量
{
    head = (LNode *)malloc(sizeof(LNode)); //创建头结点，头指针指向头结点
    head->next = NULL;                     //初始化头结点的指针域

    LNode *tail; //尾指针，尾指针始终指向最后一个结点
    tail = head; //初始化尾指针  指向最后一个结点（头结点）

    LNode *node; //新结点指针

    for (int i = 0; i < count; i++) //循环创建链表
    {
        node = (LNode *)malloc(sizeof(LNode)); //创建新结点，新结点指针指向新结点
        node->data = value[i];                 //初始化新结点的数据域

        tail->next = node; //插入到链表的头结点和前一新结点之间
        tail = tail->next; //移动尾指针
        //或者tail=node;
    }

    tail->next = NULL; //尾指针指向空   创建完成
    //链表描述：头结点->...->前一新结点->当前新结点->空

    return;
}

//按值查找
//时间复杂度：O(n)
LNode *find_node(LNode *head, ELEM_TYPE elem) //参数：头指针，元素  返回值：结点指针
{
    LNode *p;       //移动结点指针
    p = head->next; //初始化移动结点指针 指向第一个结点（头结点的下一个结点）

    while (p != NULL) //遍历
    {
        if (p->data == elem) //匹配
        {
            break; //退出查找
        }

        p = p->next; //若不匹配，移动结点指针
    }

    return p; //若找到返回结点指针，否则返回空指针
}

//按序查找
//时间复杂度：O(n)
LNode *get_node(LNode *head, int i) //参数：头指针，元素查找的位置   返回值：结点指针
{
    LNode *p;       //移动结点指针
    p = head->next; //初始化移动结点指针 指向第一个结点（头结点的下一个结点）

    if (i < 0) //不存在负数的位置
    {
        return NULL; //返回空指针
    }

    if (i == 0) //第0个位置是头结点
    {
        return head; //返回头指针
    }

    for (int j = 1; j < i; j++) //遍历
    {

        if (p != NULL) //不匹配
        {
            p = p->next; //移动结点指针
        }
        else //匹配
        {
            break; //退出查找
        }
    }

    return p; //若找到返回结点指针，否则返回空指针
}

//插入  前插
//时间复杂度：O(n)
//因为需遍历找到元素插入位置之前的结点
void insert_node(LNode *&head, int posi, LNode *node) //参数：头指针，元素插入的位置，结点
{
    LNode *p;                     //移动结点指针
    p = get_node(head, posi - 1); //初始化移动结点指针 指向第posi-1个位置的结点

    node->next = p->next; //插入 在第posi-1个位置的结点之后，占据第posi个位置，在原第posi个位置的结点之前
    p->next = node;

    return;
}

//插入  扩展：前插转后插
//时间复杂度：O(1)
//直接在元素插入位置之后的结点插入，再交换结点数据
void insert_node_exten(LNode *&head, int posi, LNode *node) //参数：头指针，元素插入的位置，结点
{
    LNode *p;                 //移动结点指针
    p = get_node(head, posi); //初始化移动结点指针 指向第posi个位置的结点

    node->next = p->next; //插入 在第posi个位置的结点之后
    p->next = node;

    ELEM_TYPE temp; //临时数据

    temp = p->data; //交换第posi个位置的结点和新结点的数据
    p->data = node->data;
    node->data = temp;

    return;
}

//删除  前删
//时间复杂度：O(n)
//因为需遍历找到元素删除位置之前的结点
void delele_node(LNode *&head, int posi) //参数：头指针，元素删除的位置
{
    LNode *p;                     //移动结点指针
    p = get_node(head, posi - 1); //初始化移动结点指针 指向第posi-1个位置的结点

    LNode *q;    //被删结点指针
    q = p->next; //初始化被删结点指针 指向第posi个位置的结点

    p->next = q->next; //修改指针指向   第posi-1个位置的结点的指针指向第posi+1个位置的结点
    //或者p->next=p->next->next;

    free(q); //删除被删结点指针指向的结点，释放内存
}

//删除  前删转后删
//时间复杂度：O(1)
//交换结点数据，直接删除元素删除位置之后的结点
void delele_node_exten(LNode *&head, int posi) //参数：头指针，元素删除的位置
{
    LNode *p;                 //移动结点指针
    p = get_node(head, posi); //初始化移动结点指针 指向第posi个位置的结点

    LNode *q;    //被删结点指针
    q = p->next; //初始化被删结点指针 指向第posi+1个位置的结点

    p->data = q->data; //交换第posi个位置和第posi+1个位置结点的数据 此时需删除的是第posi+1个位置的结点
    //或者p->data=p->next->data
    p->next = q->next; //修改指针指向   第posi个位置的结点的指针指向第posi+2个位置的结点
    //或者p->next=p->next->next;

    free(q); //删除被删结点指针指向的结点，释放内存
}

//获取表长
int get_length(LNode *head) //参数：头指针  返回值：表长
{
    LNode *p;       //移动结点指针
    p = head->next; //初始化移动结点指针 指向第一个结点（头结点的下一个结点）

    int length = 0; //表长

    while (p != NULL) //遍历 有结点
    {
        length++;    //表长递增
        p = p->next; //移动指针
    }

    return length; //返回表长
}

//清空
void clear_list(LNode *&head) //参数：头指针
{
    LNode *p;       //被删结点指针
    p = head->next; //初始化被删结点指针 指向第一个结点（头结点的下一个结点）

    LNode *q; //记录结点指针 指向被删结点的下一个结点

    while (p != NULL) //遍历    有结点
    {
        q = p->next; //记录被删结点的下一个结点

        free(p); //删除被删结点指针指向的结点，释放内存

        p = q; //移动指针    指向下一个被删结点
    }

    head->next = NULL; //头结点的指针域置空 当退出遍历时已无数据结点
}

//合并两递增表成递增表
//思路：遍历两递增表，比较结点的数值域数据，使用尾插法创建新递增表
//参数：递增表1的头指针，递增表2的头指针，新递增表的头指针
void merge_list_increase(LNode *head1, LNode *head2, LNode *&head3)
{
    LNode *p;        //移动结点指针1
    p = head1->next; //初始化移动结点指针1 指向递增表1的第一个结点（头结点的下一个结点）

    LNode *q;        //移动结点指针2
    q = head2->next; //初始化移动结点指针2 指向递增表2的第一个结点（头结点的下一个结点）
    free(head2);     //释放递增表2的头结点  因为已用移动结点指针2记录递增表2的第一个结点，数据不会丢失

    head3 = head1;      //初始化新递增表的头指针 指向递增表1的头结点，用递增表1的头结点作为新递增表的头结点
    head3->next = NULL; //初始化新递增表头结点的指针域，置空  因为已用移动结点指针1记录递增表1的第一个结点，数据不会丢失

    LNode *tail;  //新递增表的尾指针    始终指向新递增表的终端结点
    tail = head3; //初始化新递增表的尾指针  初始时新递增表为空，尾指针指向头结点

    while ((p != NULL) && (q != NULL)) //遍历两递增表
    {
        if (p->data <= q->data) //比较结点的数值域数据
        {
            tail->next = p; //将数据域数值小的结点插入新递增表表尾

            p = p->next;       //递增表1的当前结点已插入新递增表，更新移动结点指针1
            tail = tail->next; //更新新递增表的尾指针  始终指向新递增表的终端结点
        }
        else //同理
        {
            tail->next = q;

            q = q->next;
            tail = tail->next;
        }
    }

    tail->next = NULL;
    //可以没有，因为最后还要将未插入的结点插入新递增表表尾，未插入结点的终端结点指针域为空

    if (p != NULL) //若递增表2插入完成，递增表1还有未插入结点，则将剩余结点插入新递增表尾部
    {
        tail->next = p;
    }
    if (q != NULL) //若递增表1合并完成，递增表2还有未插入结点，则将剩余结点插入新递增表尾部
    {
        tail->next = q;
    }

    return;
}

//合并两递增表成递减表
//思路：遍历两递增表，比较结点的数值域数据，使用头插法创建新递减表
//参数：递增表1的头指针，递增表2的头指针，新递增表的头指针
void merge_list_reduce(LNode *head1, LNode *head2, LNode *&head3)
{
    LNode *p;        //移动结点指针1
    p = head1->next; //初始化移动结点指针1 指向递增表1的第一个结点（头结点的下一个结点）

    LNode *q;        //移动结点指针2
    q = head2->next; //初始化移动结点指针2 指向递增表2的第一个结点（头结点的下一个结点）
    free(head2);     //释放递增表2的头结点  因为已用移动结点指针2记录递增表2的第一个结点，数据不会丢失

    head3 = head1;      //初始化新递减表的头指针 指向递增表1的头结点，用递增表1的头结点作为新递减表的头结点
    head3->next = NULL; //初始化新递减表头结点的指针域  因为已用移动结点指针1记录递增表1的第一个结点，数据不会丢失

    LNode *temp; //临时结点指针 指向当前要插入新递减表表头的结点

    while ((p != NULL) && (q != NULL)) //遍历两递增表
    {
        if (p->data <= q->data) //比较结点的数值域数据
        {
            temp = p;    //将临时结点指针指向数据域数值小的结点
            p = p->next; //递增表1的当前结点已被临时结点指针记录，更新移动结点指针1

            temp->next = head3->next; //将临时结点指针指向头结点的下一个结点
            head3->next = temp;       //将头指针指向当前要插入新递减表表头的结点
        }
        else //同理
        {
            temp = q;
            q = q->next;

            temp->next = head3->next;
            head3->next = temp;
        }
    }

    if (p != NULL) //若递增表2插入完成，递增表1还有未插入结点，则取剩余结点一个个插入新递减表表头
    {
        temp = p;
        p = p->next;

        temp->next = head3->next;
        head3->next = temp;
    }
    if (q != NULL) //若递增表1插入完成，递增表2还有未插入结点，则取剩余结点一个个插入新递减表表头
    {
        temp = q;
        q = q->next;

        temp->next = head3->next;
        head3->next = temp;
    }

    return;
}

总结

不同参考资料中，单链表的描述实现各不相同，但基本思想是一致的。作者使用规范的变量命名、提供详细的步骤解析及使用示例，应用C/C++语言将其整合成模板，以帮助理解记忆。

作者的话

  • 作者：夜悊
  • 版权所有，转载请注明出处，谢谢~
  • 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获

参考资料

  • 《2023版数据结构高分笔记》主编：率辉
  • 《2023年计算机组成原理考研复习指导》组编：王道论坛
  • 《大话数据结构》作者：程杰
夜悊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
密码学：C／C++语言实现(第2版)
04-27
密码学：C/C++语言实现(原书第2版)主要阐述如何使用C和C++语言实现密码学算法，包括编写专家级的密码所需要掌握的知识和技术，以及如何安全并高效地实现密码学算法。第2版包括了许多全新内容，同时对原有内容进行了...
数据结构单链表初始化c/c++语言代码实现
01-22
很多刚接触数据结构的小白在学完单链表，只知道理论知识，却不知道如何实现，这是用c++语言实现的两种单链表初始化过程
C++实现单链表（Single Linked List）
weixin_42133358的博客
05-14 7770
C++实现单链表（Single Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 单链表是线性表的链式存储结构，同顺序存储结构（可以理解为C++中的数组）不同的是，单链表在插入和删除一个结点时，不需要移动大量的元素，但是单链表没有数组中索引的概念，所以在查询一个元素
单链表模板类c++实现
SWC0619的博客
03-23 3634
c++实现单链表
单链表的基本操作C++
alanmian的博客
11-05 7620
在这里插入代码片@TOC 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式
C++链表常用的函数编写（增查删改）内附完整程序
凉开水白菜的博客
08-25 3783
链表目录一、链表主体二、创建链表三、链表的应用1.打印链表2.求链表长度3.插入数据（按照指定位置）4.插入数据（头插）5.插入数据（尾插）6.查找元素是否存在7.删除指定位置数据8.删除最后一个节点9.删除第一个节点10.修改节点数据11.清空链表节点四、完整程序五、运行结果六、总结 一、链表主体 // 链表结构体 typedef struct node { int date; struct node *next; // 还未定义别名只能使用struct node定义next指针 }
C++实现单链表
琅嬛福地
04-13 343
本篇介绍如何用C++实现单链表 首先需要定义节点 Node.h #ifndef NODE_H #define NODE_H class Node { public: int data; Node *next; public: void printNode(); }; #endif Node.cpp #include "Node.h" #include <iostream> using namespace std; void Node::printNode() { cout &l
C语言/C++基础之实现绕线画代码
12-20
C语言/C++基础之实现绕线画代码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
C/C++语言的主要特征
01-19
1．标准的ANSI C/C++语言 　TMS320X28xx编译器符合ANSI定义的ANSI C标准，该标准在Kernighan和Ritchie编写的C Programming Language，2e中有详细的定义，国内出版的C语言编程的书籍中也有详细的编程方法。此外，TMS...
操作系统实验一报告【使用C语言/C++实现时间片轮转调度算法】
02-27
操作系统实验一报告【使用C语言/C++实现时间片轮转调度算法】
单链表（完整 含main方法）
热门推荐
KAKA的博客
09-25 2万+
链表： 通过一组任意的存储单元来存储线性表中的数据元素，由一个个结点构成。 链表之所以让初学者难以理解，是因为要回溯到上一个结点，并利用这个结点，很多人的思维一直都是往下面追溯，所以才会觉得难以理解，多动手画画图会容易理解许多。 链表示意图： 结点： 结点类型如下： typedef struct lnode{ datatype data; //数据域 struct ...
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6059
单链表的操作与实现
单链表的c++和c语言的写法（一）
就爱摆烂
03-28 457
单链表的c++和c语言的写法（一） 使用c++语法写一个单链表。 首先定义一个类，取名为LinkNode。 #include<iostream> using namespace std; typedef struct SListNode//结构体 { int data; SListNode* next; }SN,SListNode; class LinkNode { public: void SListNodeInit(); //初始化函数 void SListNodePrint
【java-数据结构15-模拟实现栈的方法】
2302_80519942的博客
05-14 563
上篇文章中，我们已经手动实现了栈，下面，我们将继续手动实现栈的方法~
数据结构--单链表的基本操作
2301_78724721的博客
05-14 645
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的。链表也是线性表的一种。链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。只 需要将⽕⻋⾥的某节⻋厢去掉/加上，不会影响其他⻋厢，每节⻋厢都是独⽴存在的。⻋厢是独⽴存在的，且每节⻋厢都有⻋⻔。想象⼀下这样的场景，假设每节⻋厢的⻋⻔都是锁上的状 态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从⻋头⾛到⻋尾？
数据结构 | 详解栈实现队列&队列实现栈
mooridy的博客
05-17 325
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
数据结构--栈和队列 源码
最新发布
Mike的博客
05-18 573
数据结构——栈和队列的实现
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1061
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
密码学:c/c++语言实现百度
10-02
同时，C/C++语言也可以方便地调用操作系统提供的API接口，以实现与其他系统的安全通信。 总之，密码学在C/C++语言中的实现是一项重要的任务，需要密切结合密码学理论和C/C++编程技术，以保证信息的安全性和可靠性。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值