[C++] 数据结构应用——链表

通过C/C++编程实现数据结构与算法:链表、树、图的应用! 🏆本文收录于「编程与技术实战」专栏,此专栏涵盖了C/C++编程、人工智能、数据结构、机器学习等技术领域的内容,助你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!! 阅读详情

C++ 数据结构应用——链表


代码已经封装成class啦,方便使用。


头文件:Linklist.h

#include <iostream>
/******************************************************
Copyright: University of Science & Technology Beijing
Author: Turing Aaron
Date: 2017-05
Description:
        ProgrammingLanguage: C++
        FunctionName   -------- Description
        Createlist()            创建链表,申请链表头节点的空间,并将头节点的next指针指向NULL。
        ListInsert()            按给定链表位置序号找到位置并将元素插入到该序号后面。
        ListClear()             遍历链表,依次释放节点的内存。
        ListDel()               按照给定序列的值从链表中删除该结点。
        GetElem()               按序号查找链表中的元素,并返回该节点的指针。
        LocateElem()            按值查找(定位)链表中的元素,并返回该节点的指针。
        print()                 遍历链表并打印元素的data.
        isEmpty()               判断链表是否为空。
        Adjmax()                计算相邻k个节点data值之和最大的第一节点。

*******************************************************/

class LinkList
{
public:
    //链表的构造函数,调用私有方法中的Creatlist(),下同,都是通过公共函数调用私有函数
    LinkList() { Createlist(); }
    int Adjmax(const int & k) {
        return Adjmax(head, k);
    }

    const int & GetElem(int i) {
        return GetElem(head, i)->data;
    }
    const int & LocateElem(const int & data) {
        LocateElem(head, data);
    }
    bool ListInsert(const int &i, const int & data) {
        return ListInsert(head, i, data);
    }
    bool ListDel(const int &i) {
        ListDel(head, i);
    }
    void ListClear() {
        ListClear(head);
    }
    void print() {
        print(head);
    }
    bool isEmpty() {
        return isEmpty(head);
    }

private:
    struct LinkNode
    {
        int data;
        LinkNode *next;

        //LinkNode的初始化函数(调用new时会调用这个函数)
        LinkNode(const int & data, LinkNode *next = NULL)
            : data(data), next(next) { }
    };

    LinkNode *head;

    void Createlist();
    int Adjmax(LinkNode * & L, const int & k);
    void ListClear(LinkNode * & H);
    LinkNode * GetElem(LinkNode * H, int i) const;
    LinkNode * LocateElem(LinkNode *H, const int & data) const;
    bool ListInsert(LinkNode * & H, const int & i, const int & data) const;
    bool ListDel(LinkNode * & H, const int & i);
    void print(LinkNode * H);
    bool isEmpty(LinkNode * & head);

};

/*******************************************************
Function:       Adjmax().
Description:    计算相邻k个节点data值之和最大的第一节点.
Arguments:      链表头节点 LinkNode * & L, 链表长度 const int & k .
Variables:
        VariableName   -------- Description
        LinkNode* p             记录当前区间头指针
        LinkNode* q             记录当前区间尾指针
        int sum                 记录当前区间内所有data之和;
        int maxSum              记录和最大的值;
        int maxNode             记录和最大的那个区间的第一个节点位置;
        int curNode             记录当前区间第一个节点位置。

Return:         和最大的第一节点在链表中的序号
*******************************************************/
int LinkList::Adjmax(LinkNode * & L, const int & k) {
    //检测空链表
    if (L->next == NULL) return 0;

    //curNode为当前计数区间的头一个结点
    int sum = 0, maxSum = 0, maxNode = 1, curNode = 1;
    LinkNode *p = NULL, *q = NULL;
    p = q = L->next;

    //根据k的范围移动q指针,sum记录为q到p区间内的和
    //初始化sum,记录和为[1, k]的数据。  
    for (int i = 1; i <= k ; i++) {
        sum += q->data;
        q = q->next;
        if(q==NULL){
            std::cout << "[-] ---------- 您输入的k值小于链表长度 ----------" << std::endl;
            return maxNode;
        }
    }
    maxSum = sum;

    //开始移动长度为k的区间,减去前一个元素,加上后一个元素,同时移动curNode,如果sum更大,则更新maxNode
    while (q) {
        sum -= p->data;
        p = p->next;
        curNode++;
        sum += q->data;

        q = q->next;
        if (sum > maxSum) {
            maxSum = sum;
            maxNode = curNode;
        }
    }
    return maxNode;
}

//创建链表,申请链表头结点的空间,并将头节点的next指针指向NULL。
void LinkList::Createlist() {
    head = new LinkNode(0);
}

//遍历链表,依次释放结点的内存。
void LinkList::ListClear(LinkNode * & H) {
    LinkNode * p;
    p = H;
    //从头结点开始循环删除
    while (p)
    {
        LinkNode *q;
        q = p->next;
        delete p;
        p = q;
    }

}

//按序号查找链表中的元素,并返回该节点的指针。
LinkList::LinkNode * LinkList::GetElem(LinkNode * H, int i) const {
    //输入的i小于0或链表为空时返回NULL
    if (i < 0)
        return NULL;
    //新建指针指向表头
    LinkNode * P = H;
    //由于是从表头开始遍历,所以开始时位置为-1
    int j = -1;
    //从表头开始遍历i个节点
    while (P->next && j < i)
    {
        P = P->next;
        ++j;
    }
    //成功遍历到第i个节点,返回该元素的指针
    if (i == j) return P;
    //否则返回空指针
    else return NULL;
}

//按值查找(定位)链表中的元素,并返回该节点的指针。
LinkList::LinkNode * LinkList::LocateElem(LinkNode *H, const int & data) const {
    //新建指针指向第一个元素
    LinkNode * P = H->next;
    //遍历链表,如果没找到data,P指针为NULL
    while (P && P->data != data)
        P = P->next;
    return P;

}

//按给定链表位置序号找到位置并将元素插入到该序号后面。
bool LinkList::ListInsert(LinkNode * & H, const int & i, const int & data) const {
    LinkNode * p, *q;
    if (i == 0) p = H;
    else p = GetElem(H, i - 1);
    if (p == NULL)
        return false;
    else
    {
        //在q中存入数据,并把p指针的下一位给新节点q
        q = new LinkNode(data, p->next);
        p->next = q;
        return true;
    }
}

//按照给定序列的值从链表中删除该结点。
bool LinkList::ListDel(LinkNode * & H, const int & i) {
    LinkNode *p, *q;
    //如果输入位置为0,则从头开始删除
    if (i == 0)
        p = H;
    //如果不是,则查找该元素
    else
        p = GetElem(H, i - 1);
    if (p&&p->next)
    {
        q = p->next;
        p->next = q->next;
        delete q;
        return true;
    }
    else
        return false;
}

//遍历链表并打印元素的data.
void LinkList::print(LinkNode * H) {
    if (H == NULL)
        return;
    for (LinkNode *p = head->next; p; p = p->next) {
        std::cout << p->data << "\t";
    }
    std::cout << std::endl;
}

//判断链表是否为空。
inline bool LinkList::isEmpty(LinkNode * & head) {
    return head == NULL ? true : false;
}


主文件:list_app.cpp

#include "LinkList.h"
#include <string>
#include <ctype.h>
#include <fstream>
#include <sstream>
#include <limits>

using namespace std;
int main()
{

    cout << "实验1:链表的应用 -- 作者:Turing Aaron" << endl;
    while (true)
    {
    menu:
        cout << "\n[+] 是否创建链表?\n"
             << "1) 创建链表\t2) 退出系统\t3) 从文件读入数据" << endl;

        //读入操作数并将第一个字符做为操作数
        string op_input;
        cin.clear();
        getline(cin, op_input);
        int op = op_input[0] - '0';

        //1) 创建链表
        if (op == 1)
        {

            //---初始化链表---
            cout << "[+] ---------- 正在初始化链表... ----------" << endl;
            LinkList *myList = new LinkList;
            cout << "[+] ---------- 初始化完毕,接下来请输入k值 ----------" << endl;
            int k = 0;
            while (true)
            {
                cin >> k;
                if (cin.good())
                    break;
                else if (cin.fail())
                {
                    cout << "[-] ---------- k值输入错误,请重新输入!----------" << endl;
                    //清空输入流
                    cin.clear();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                }
            }

            //---数据读取---
            cout << "[+] ---------- 请输入数据,#结束输入 ----------" << endl;
            cin.clear();
            int data = 0, listLen = 0;
            while (true)
            {
                cin >> data;

                //如果读入的是数字,则插入链表
                if (cin.good())
                    myList->ListInsert(listLen++, data);

                //如果输入的不是数字,输入流cin的fail会被置位,此时读入一个字符,判断是#还是非法字符。
                else if (cin.fail())
                {
                    char c = getchar();
                    if (c == '#')
                        break;
                    cin.ignore();
                    cout << "[-] ---------- 输入的【 " << c << " 】非法,该输入跳过! ----------" << endl;
                    //清空错误输入流
                    cin.clear();
                }
            }

            //---判断链表内是否有数据---
            if (myList->isEmpty())
            {
                myList->ListClear();
                goto menu;
            }

            //---输出链表---
            cout << "[+] ---------- 您输入的链表为: ----------" << endl;
            myList->print();

            //---调用Adjmax()求值---
            cout << "[+] ---------- 开始计算相邻 [ " << k << " ] 个节点和最大的第一个节点 ----------" << endl;
            int maxNode = myList->Adjmax(k);
            if (maxNode == 0)
                cout << "[-] ---------- 链表为空!请检查!----------" << endl;
            else
            {
                cout << "[+] 相邻 " << k << " 个结点data值之和为最大的第一结点为: " << endl;
                cout << "[+] 序号" << maxNode << ", data值" << myList->GetElem(maxNode - 1) << endl;
            }
            cout << "[+] ---------- 计算结束 ----------" << endl;

            //---析构链表---
            myList->ListClear();

            //---清除输入流---
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
        }

        //2) 退出系统
        else if (op == 2)
        {
            cout << "[+] ---------- 感谢使用,再见 ----------" << endl;
            exit(0);
        }

        //3) 从文件读入数据
        else if (op == 3)
        {
            //------从文件读入数据------
            string file_name;
            cout << "[+] ----------- 请输入要读取的文件名字 ---------" << endl;
            getline(cin, file_name);
            ifstream fin(file_name);
            //------打开文件失败------
            if (!fin)
            {
                cout << "[-] ---------- 找不到数据文件,请检查! ----------" << endl;
                goto menu;
            }
            //在读到文件结束以前
            while (fin.peek() != EOF)
            {
                int k = 0;
                string k_input, data_input;
                getline(fin, k_input);
                //如果k的输入非空且第一个字符为数字,则判断为k的输入有效,否则退出循环
                if (!k_input.empty())
                    k = k_input[0] - '0';
                else
                    break;

                //建立链表
                LinkList *myList = new LinkList;
                getline(fin, data_input);

                //将data字符串输入变为数据流,方便链表读取
                istringstream sin(data_input);
                int data = 0, listLen = 0;
                while (sin >> data)
                {
                    myList->ListInsert(listLen++, data);
                }

                //---输出链表---
                cout << "[+] ---------- 您输入的链表为: ----------" << endl;
                myList->print();

                //---调用Adjmax()求值---
                cout << "[+] ---------- 开始计算相邻 [ " << k << " ] 个节点和最大的第一个节点 ----------" << endl;
                int maxNode = myList->Adjmax(k);
                if (maxNode == 0)
                    cout << "[-]  ---------- 链表为空!请检查! ----------" << endl;
                else
                {
                    cout << "[+] 相邻 " << k << " 个结点data值之和为最大的第一结点为: " << endl;
                    cout << "[+] 序号" << maxNode << ", data值" << myList->GetElem(maxNode - 1) << endl;
                }
                cout << "---------------------------------------------------------------------------------------" << endl;

                //---析构链表---
                myList->ListClear();
            }
            fin.close();
        }

        //非法参数
        else
            cout << "[-] ---------- 非法参数,请重试! ----------" << endl;
    }
    return 0;
}

其他的以后有空再补充哈

C/C++链表数据结构全解析:从基础实现到工程应用实战 数据结构是计算机科学中组织和管理数据的基础,其核心在于通过特定方式将数据元素关联起来,以实现高效访问和操作。链表作为一种基础数据结构,其原理是通过指针将分散在内存中的结点(Node)按逻辑顺序链接,形成物理非连续但逻辑连续的数据序列。这种设计的技术价值在于提供了动态内存分配和高效的插入删除能力,时间复杂度可达O(1),克服了数组需要连续内存和移动元素的局限。在应用场景上,链表非常适合处理数据规模频繁变化、需要频繁增删的场合,例如实时聊天系统的用户列表管理、操作系统内核的任务调度队列、以及实现高级数据结构如栈 阅读详情

相关推荐

【023】C/C++数据结构之链表及其实战应用

链表(Linked List)是一种常见的数据结构,它由若干个节点(Node)组成,每个节点包含一个数据元素和指向下一个节点的指针。相邻两个节点之间通过指针连接起来,形成了链式结构。链表可以分为单向链表、双向链表和循环链表三种类型。其中单向链表每个节点只有一个指向下一个节点的指针;双向链表每个节点除了有指向下一个节点的指针外,还有指向前一个节点的指针;循环链表则是将最后一个节点的指针指向头结点,使得整个链条形成了一个闭环。

Lion_Long的博客 1207

linux内核线程freezing,Linux内存管理 (13)回收页面

关键词:LRU、活跃/不活跃-文件缓存/匿名页面、Refault Distance。node页面回收、或者回收页面也即page reclaim,依赖于LRU链表对页面进行分类:不活跃匿名页面、活跃匿名页面、不活跃文件缓存页面、活跃文件缓存页面和不可回收页面。算法内存紧张时优先换出文件缓存页面,而后才是匿名页面。由于文件缓存页面有后备存储器,而匿名页面必需要写入交换分区。缓存因此回收页面的三种机制(...

weixin_35665083的博客 1075

使用链表实现队列,是数据结构中一个经典的应用之一。在C++语言中,我们可以通过链表来实现队列。

在C++语言中,我们可以通过定义链表节点以及相关操作函数来实现队列。使用链表实现队列具有先进先出的特点,并可以适用于任务调度、缓存控制、消息传递等方面。队列是一种特殊的线性表,只允许在表的一端进行插入操作,在另一端进行删除操作。在使用链表实现队列时,我们需要定义链表节点。使用链表实现队列,是数据结构中一个经典的应用之一。在C++语言中,我们可以通过链表来实现队列。定义好链表节点后,我们需要定义队列以及队列的相关操作函数。接下来,我将为大家介绍如何使用链表实现队列,并附上完整的源代码。

DevProPlus的博客 160

C++链表的应用实例

题一:编写一个算法判断链表中的数据项是否按从小到大排序,该链表的第一个节点由first指向。题二:对于给定的整数n,编写一个算法把新节点插入到链表中第n个节点之后的位置,该链表的第一个节点由first指向。题三:编写一个算法来颠倒一个链表,该链表的第一个节点由first指向。不要复制列表元素,而是重置链接和指针,是的first指向原来的最后一个节点,且节点之间的所有链接都反向。 #incl...

Shang1031 1539

C++数据结构:链表的完整实现与应用

链表作为一种基础的数据结构,其节点的定义和结构体的设计至关重要。理解这些基础概念,是使用C++实现链表的前提。在C++中,链表的节点可以通过结构体或者类来定义。每个节点通常包含数据部分和指向下一个节点的指针。以下是一个简单链表节点的定义:int val;// 节点存储的数据部分// 指向下一个节点的指针根据链表节点间关系的不同,链表可以分为单链表和双向链表。单链表的节点只有指向下一个节点的指针,而双向链表的节点还包含指向前一个节点的指针。int val;int val;

weixin_31749299的博客 908

C++实现十字链表:高级数据结构应用与实践

C++模板类是一种泛型编程工具,允许用户创建一个可以操作任何数据类型的类。模板类的定义使用关键字template后跟一个或多个模板参数的列表,通常使用typename或class关键字。下面是一个模板类的基本定义示例:private:T data;public:在这个例子中,Node是一个模板类,它可以存储任何类型的T的数据。模板参数T在类定义中作为类型使用,允许我们在创建Node对象时指定存储数据的类型。在十字链表中,节点是构成整个数据结构的基础单元。

weixin_36059856的博客 447

链表及代码

一、线性表的链式存储结构 前面所讲的线性表的顺序存储结构是有缺点的,最大的缺点就是插入和删除时需要移动大量的元素,这显然就需要耗费大量时间。 仔细考虑一下产生该问题的原因,在于相邻元素的存储位置也具有邻居关系,它们在内存中是紧挨着的,没有空隙,自然也没有空位进行介入,而删除后留下的空隙自然也需要弥补。 为了解决上述问题,我们打破常规,不再让相邻元素在内存中紧挨着,而是上一个元素留存下一个元素...

ZHYFXY的博客 1026

C/C++静态链表数据结构实现与应用详解

✅推荐使用场景- 嵌入式系统(MCU、RTOS)- 实时控制系统(PLC、ECU、无人机)- 对内存安全要求高的场合- 频繁增删但总量可控的数据结构- 中断上下文中需要操作链表❌不适用场景- 数据量完全不可预测- 需要长期运行且不断增长的链表- 上层应用软件(服务器、桌面程序)一句话总结:当你担心malloc会搞砸一切时,就该考虑静态链表了。它不是为了替代动态链表,而是为那些“容不得半点闪失”的系统提供一种更稳健的选择。

weixin_36303305的博客 967

链表的应用

题目:求相邻k个节点数值之和最大的第一节点 输入数据(设为整型)建立单链表,并求相邻k个节点data值之和为最大的第一节点。例如输入k = 2,数据为2 6 4 7 3 #(#为结束符),建立下面链表,运行结果输出(序号3,data值4): 书上学的数据结构总是用指针和链表来操作,和刷题时的程序有点不一样,需要多练习 #include #include int k,k1;

天行健,君子以自强不息 3311

c语言链表的综合应用

c语言初级的链表综合应用,适合于初学c语言的各位亲。

CAN总线错误帧全解析:从数据包到硬件层的故障树分析

本文深入解析CAN总线错误帧的故障树分析方法,从数据包到硬件层全面剖析错误机制。通过物理层信号测试、数据链路层错误解码和应用层协议排查,提供系统化的诊断框架。结合CANoe配置和示波器波形分析,帮助工程师快速定位总线故障,提升系统可靠性。

weixin_26742753的博客 495

数据结构关于链表的代码如下

//注意:该文件操作的单链表为带头结点单链表,头结点数据为-1#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;time.h&gt;#define OK 1#define ERROR 0typedef int ;typedef struct Node{ data_t data; struct Node *next;}Nod...

hash_world的博客 456

dxf-viewer 查看器

dxf-viewer SDK 的示例,它是一个基于 Three.js 和 Vue3 构建的基于 WebGL 的 BIM 模型查看器。它用于查看 DWG/DXF/PDF 文件。面积测量 - 角度测量 -标记。

qq_25547755的博客 867

C++数据结构与算法详解:链表、栈、队列、树、二叉树和图结构的实现与应用

链表是一种常用的线性数据结构,它可以动态的添加或删除元素并且没有固定大小 栈是一种后进先出的数据结构所有元素都在栈顶,可以理解为一种特殊的列表。 队列是一种先进先出的数据结构所有元素被放置在队列的末尾并从队列的开头移除。 树是一种非线性数据结构由由节点组成,并且节点之间有特定的关系(如父节点、子节点等) 图是一种非线性的数据结构由一个或多个节点组成并且节点之间有关联

BXA 2750

Workbench中直接调用ICEM CFD进行网格划分

自从ANSYS 12.0之后,ICEM CFD就从Workbench中被分离出去,作为一个独立的程序使用了。取而代之的是Meshing模块。 在Meshing的属性节点菜单中右键点击Mesh,选择Insert > Method,插入方法。 选择需要划分网格的几何体,点击apply。此时Geometry显示为1 Body。 设置Method为MultiZone,如果不设置成这个的话,找不到进入ICEM CFD的入口。如果要划分四面体,可以在Mapped Mesh Type中选择其他类型。

Yan的博客 6513

【Photoshop JSX脚本】强大的事件监听器脚本 - event_listener.jsx

新手第一次了解的事件监听一定是ScriptingListener.8bi插件,如果你对此插件有了基本运用,那么现在了解一款更方便的时间监听脚本event_listener.jsx。不再像ScriptingListener.8bi插件那样晦涩难懂。 1、准备event_listener.jsx文件到 F:\Program Files\Adobe Photoshop 2020\Presets\...

Greless的后花园 8210

C++数据结构 ---- 双链表

环境配置 codeblocks windows10 项目结构 代码 DLinkListClass.cpp #ifndef _DLINKLISTCLASS_H_ #define _DLINKLISTCLASS_H_ template <typename T> class DLinkListNode { public: T data; DLinkListNode&l...

Jade1998 186

国民技术N32G45X SysTick定时器实战:从1us到100ms的精准延迟实现(附完整代码)

本文详细解析了国民技术N32G45X芯片中SysTick定时器的工作原理,并提供了从1微秒到100毫秒的高精度延迟实现方案。通过对比官方库函数的局限性,文章重点介绍了无中断查询模式、时钟源选择策略以及完整的代码实现,帮助嵌入式开发者精准控制时序,适用于LED控制、软件模拟通信协议等多种实战场景。

weixin_29190573的博客 378

《数据结构、算法与应用C++语言描述》使用C++语言实现链表队列

《数据结构、算法与应用C++语言描述》使用C++语言实现链表队列。

Jasmine-Lily的博客 646

DataWorks数据安全治理最佳实践

DataWorks基于数据安全治理的常见思路,针对资产梳理、技术体系建设和运营体系建设,提供了一系列数据安全产品能力,您可通过“基础防护建设、数据安全防护措施及策略增强建设、数据安全持续运营”三个阶段在DataWorks上落地数据安全治理项目。参考本文启动数据安全治理项目前,建议您先了解DataWorks数据安全产品相关能力了解DataWorks数据安全产品能力后,您可参考如下三个阶段在DataWorks上落地数据安全治理项目。

soso1968的博客 1439

特征工程自动化(FeatureTools实战)

本项目模拟生成的医疗、金融和电商等领域的原始数据,适用于自动化特征工程的场景。主数据表(Entity Table):例如用户数据、交易数据、患者数据等。字段可能包括用户ID、年龄、性别、注册日期、消费金额、行为记录等。关联数据表(Related Tables):例如订单数据、点击记录、诊疗记录等。多个表之间通过外键建立关联。patient_id:患者IDage:年龄gender:性别:入院日期:出院日期diagnosis:诊断结果。

闲人编程的博客 1361

《数据结构、算法与应用C++语言描述》线性表-链表描述

《数据结构、算法与应用C++语言描述》线性表-链表描述

Jasmine-Lily的博客 1169

ANPC三电平拓扑双脉冲试验的原理与实施

ANPC三电平拓扑因损耗低、谐波小、应力均衡而广泛应用,但其存在短、长两类换流通道,寄生电感和开关应力差异显著。短通道尖峰小、可靠性高;长通道应力严苛。因此需分别制定两套独立双脉冲测试方案,针对不同时段和器件(如T1、T5、T6、T4及对应二极管)全面考核开关特性。

嵌入式老牛的博客 357

数据结构算法与应用-C++语言描述 stack链表的实现

//数据结构算法与应用-C++语言描述 stack链表的实现 //链表描述 main.cpp #include <iostream> #include <sstream> #include <iterator> using namespace std; //数据结构算法与应用-C++语言描述 chain 单链表 //一个线性表的抽象类 template <class T> class linearList { public: virtual ~lin

虾球 525

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

【和春笋一起学C++】(五十七)链表数据结构及其应用

本文介绍了链表的基本概念及其在队列实现中的应用。主要内容包括:1.链表的基本概念和结构;2.以ATM排队系统为例,详细设计了基于链表的队列类实现方案;3.重点阐述了队列的核心方法实现,包括入队(enqueue)和出队(dequeue)操作;4.讨论了析构函数、复制构造函数等特殊成员函数的实现要点;5.提供了完整的队列类实现代码。文章通过链表结构实现了队列的先进先出特性,避免了数组实现时的元素移动问题,并考虑了内存管理、异常处理等细节问题。

计算机视觉算法开发与落地 815

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

上一篇: [python] 网络数据采集 操作清单 BeautifulSoup、Selenium、Tesseract、CSV等
下一篇: [Leetcode/Javascript] 461.Hamming Distance
EnergyOverflow
博客等级 码龄10年 1粉丝 15原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值