线性表之链表结构

线性表的单链表存储结构 阅读详情

链表结构

典型的链表结构,包括如下内容:
1. 数据部分,保存的是该结点的实际数据。
2. 地址部分,保存的是下一个结点的地址。
链表结构就是由许多这种结点构成的。在进行链表操作时,首先需定义一个“头引用”变量(一般以head表示),该引用变量指向链表结构的第一个结点,第一个结点的地址部分又指向第二个结点……直到最后一个结点。最后一个结点不再指向其他结点,称为“表尾”,一般在表尾的地址部分放一个空地址null,链表到此结束。

链式存储是最常用的存储方式之一,它不仅可用来表示线性表,而且可用来表示各种非线性的数据结构。链表结构还可以细分为如下几类:
1. 单链表:同上面的链式结构一样,每个结点只包含一个引用。
2. 双向链表:若每个结点包含两个引用,一个指向下一个结点,另一个指向上一个结点,这就是双向链表。
3. 单循环链表:在单链表中,将终端结点的引用域null改为指向表头结点或开始结点即可构成单循环链表。
4. 多重链的循环链表:如果表中结点链在多个环上,将构成多重链的循环链表。

准备数据

准备在 链表操作中需要用到的变量及类。

class DATA{
    String key;         // 结点的关键字
    String name;
    int age;
}

/*
 * 定义链表结构
 * Chain-type storage structure
 */
class CLType{
    DATA nodeData = new DATA();
    CLType nextNode;
}

上述代码定义了链表数据元素的类DATA及链表的类CLType。结点的具体数据保存在一个类DATA中,而引用nextNode用来指向下一个结点。

其实可以认为该链表是一个班级学生的记录,和上面顺序表所完成的工作类似。

追加结点

追加结点即在链表末尾增加一个结点。表尾结点的地址部分原来保存的是空地址null,此时需要将其设置为新增加结点的地址(即原表尾结点指向新增结点),然后将新增结点的地址部分设置为空地址null,即新增节点成为表尾

由于一般情况下,链表只有一个头引用head,要在末尾添加结点就需要从头引用head开始逐个检查,直到找到最后一个结点(即表尾)。

CLType CLAddEnd(CLType head, DATA nodeData){
    CLType node,htemp;
    if((node=new CLType())==null){
        System.out.println("申请内存失败!\n");
        return null;
    }else{
        node.nodeData = nodeData;       // 在新申请的结点中保存数据
        node.nextNode = null;       // 设置结点引用为空,即为表尾
        if(head == null){       // 当head为空时,加入的新结点即为头引用
            head = node;
            return head;
        }
        htemp = head;
        while(htemp.nextNode != null){      // 查找链表的末尾
            htemp = htemp.nextNode;
        }
        htemp.nextNode = node;      // 在链表的末尾插入该结点
        return head;        // 返回指代整个链表的头引用
    }
}

在上述代码中,输入参数head为链表头引用,输入参数nodeData为结点保存的数据。程序中,使用new关键字申请保存结点数据的内存空间,如果分配内存成功,node中将保存指向该内存区域的引用。然后,将传入的nodeData保存到申请的内存区域,并设置该结点指向下一结点的引用值为null,最后将该结点链接到链表的末尾。

插入头结点

插入头结点即在链表的首部添加结点的过程。
步骤如下:
1. 分配内存空间,保存新增的结点。
2. 使新增结点指向头引用head所指向的结点。
3. 使头引用head指向新增结点。

CLType CLAddFirst(CLType head, DATA nodeData){
    CLType node;
    if((node = new CLType())==null){
        System.out.println("申请内存失败!\n");
        return null;
    }else{
        node.nodeData = nodeData;       // 保存数据
        node.nextNode = head;       // 新加入的头结点的nextNode指向头引用所指的结点
        head = node;        // 头引用指向新节点
        return head;
    }
}

查找结点

通过关键字进行查询。

CLType CLFindNode(CLType head, String key){
    CLType htemp;
    htemp = head;
    while(htemp!=null){         // 循环遍历,寻找关键字匹配的结点
        if(htemp.nodeData.key.compareTo(key)==0){   
            return htemp;
        }
        htemp = htemp.nextNode;
    }
    return null;
}

在上述代码中,输入参数head为链表的头引用,输入参数key是用来在链表中进行查找结点的关键字。程序中,首先从链表头引用开始,对结点进行逐个比较,直到查找到。找到关键字相同的结点后,返回该结点的引用,方便调用程序处理。

插入结点

插入结点就是在链表中间部分的指定位置增加一个结点。插入结点的操作步骤如下:
1. 分配内存空间,保存新增的结点。
2. 找到要插入的逻辑位置,也就是那两个结点之间。
3. 使新增节点指向原插入位置所指向的结点,并修改插入位置结点的引用,使其指向新增结点。

CLType CLInsertNode(CLType head, String findKey, DATA nodeData){    // 插入关键字结点
    CLType node, nodetemp;
    if((node = new CLType())==null){
        System.out.println("申请内存失败!\n");
        return null;
    }
    node.nodeData = nodeData;
    nodetemp = CLFindNode(head, findKey);       // 获取插入位置关键字所指代的结点
    if(nodetemp == null){
        System.out.println("未找到正确的插入位置!\n");
    }else{                          
        node.nextNode = nodetemp.nextNode;      // 新插入的节点的nextNode指向关键字结点的下一结点
        nodetemp.nextNode = node;               // 设置关键结点指向新插入结点
    }
    return head;
}

删除结点

删除结点就是将链表中的某个结点数据删除。删除结点的操作步骤如下:
1. 查找需要删除的结点。
2. 使前一结点指向当前结点的下一结点。
3. 删除结点。

int CLDeleteNode(CLType head, String key){      // 删除关键字结点
    CLType htemp,tempnode;
    if(head == null){
        return 0;
    }
    htemp = head;
    tempnode = head;
    while(htemp != null){
        if(htemp.nodeData.key.compareTo(key)==0){   // 遍历查找
            tempnode.nextNode = htemp.nextNode; // 当前结点的引用指向下一个结点的引用,以此删除htemp结点
            return 1;
        }
        tempnode = htemp;           // 保存当前结点
        htemp = htemp.nextNode;         // 指向下一个结点
    }
    return 0;
}

注意,此时被删除结点仍然保存在内存中,接着执行赋值null操作,用来释放被删除节点所占用的内存空间。

计算链表长度

统计链表结构中结点的数量,由于链表结构在物理上不是连续存储的,因此,需要遍历整个链表来对结点数量进行累加。

int CLLength(CLType head){          //返回结点总数
    CLType htemp;
    int len = 0;
    htemp = head;
    while(htemp!=null){             // 循环遍历累计总结点数
        len++;
        htemp=htemp.nextNode;
    }
    return len;
}

程序中通过while循环来遍历整个链表,从而累加数量并返回。

显示所有结点

void CLAllNode(CLType head){        // 遍历链表输出所有数据
    CLType htemp;
    htemp = head;
    System.out.printf("\n当前链表共有%d个结点。链表所有数据如下:\n",CLLength(head));
    while(htemp != null){
        System.out.printf("结点(%s,%s,%d)\n",htemp.nodeData.key, htemp.nodeData.name, htemp.nodeData.age);
        htemp = htemp.nextNode;
    }
}

链表操作实例

package dataStructure.linkedList;

import java.util.Scanner;

class DATA{
    String key;                                     // 结点的关键字
    String name;
    int age;
}

/*
 * 定义链表结构
 * Chain-type storage structure
 */
class CLType{
    DATA nodeData = new DATA();
    CLType nextNode;

    CLType CLAddEnd(CLType head, DATA nodeData){
        CLType node,htemp;
        if((node=new CLType())==null){
            System.out.println("申请内存失败!\n");
            return null;
        }else{
            node.nodeData = nodeData;               // 在新申请的结点中保存数据
            node.nextNode = null;                   // 设置结点引用为空,即为表尾
            if(head == null){                       // 当head为空时,加入的新结点即为头引用
                head = node;
                return head;
            }
            htemp = head;
            while(htemp.nextNode != null){          // 查找链表的末尾
                htemp = htemp.nextNode;
            }
            htemp.nextNode = node;                  // 在链表的末尾插入该结点
            return head;                            // 返回指代整个链表的头引用
        }
    }

    CLType CLAddFirst(CLType head, DATA nodeData){
        CLType node;
        if((node = new CLType())==null){
            System.out.println("申请内存失败!\n");
            return null;
        }else{
            node.nodeData = nodeData;               // 保存数据
            node.nextNode = head;                   // 新加入的头结点的nextNode指向头引用所指的结点
            head = node;                            // 头引用指向新节点
            return head;
        }
    }

    CLType CLFindNode(CLType head, String key){
        CLType htemp;
        htemp = head;
        while(htemp!=null){                         // 循环遍历,寻找关键字匹配的结点
            if(htemp.nodeData.key.compareTo(key)==0){   
                return htemp;
            }
            htemp = htemp.nextNode;
        }
        return null;
    }

    CLType CLInsertNode(CLType head, String findKey, DATA nodeData){    // 插入关键字结点
        CLType node, nodetemp;
        if((node = new CLType())==null){
            System.out.println("申请内存失败!\n");
            return null;
        }
        node.nodeData = nodeData;
        nodetemp = CLFindNode(head, findKey);       // 获取插入位置关键字所指代的结点
        if(nodetemp == null){
            System.out.println("未找到正确的插入位置!\n");
        }else{                          
            node.nextNode = nodetemp.nextNode;      // 新插入的节点的nextNode指向关键字结点的下一结点
            nodetemp.nextNode = node;               // 设置关键结点指向新插入结点
        }
        return head;
    }

    int CLDeleteNode(CLType head, String key){      // 删除关键字结点
        CLType htemp,tempnode;
        if(head == null){
            return 0;
        }
        htemp = head;
        tempnode = head;
        while(htemp != null){
            if(htemp.nodeData.key.compareTo(key)==0){ // 遍历查找
                tempnode.nextNode = htemp.nextNode; // 当前结点的引用指向下一个结点的引用,以此删除htemp结点
                return 1;
            }
            tempnode = htemp;                       // 保存当前结点
            htemp = htemp.nextNode;                 // 指向下一个结点
        }
        return 0;
    }

    int CLLength(CLType head){                      //返回结点总数
        CLType htemp;
        int len = 0;
        htemp = head;
        while(htemp!=null){                         // 循环遍历累计总结点数
            len++;
            htemp=htemp.nextNode;
        }
        return len;
    }

    void CLAllNode(CLType head){                    // 遍历链表输出所有数据
        CLType htemp;
        htemp = head;
        System.out.printf("\n当前链表共有%d个结点。链表所有数据如下:\n",CLLength(head));
        while(htemp != null){
            System.out.printf("结点(%s,%s,%d)\n",htemp.nodeData.key, htemp.nodeData.name, htemp.nodeData.age);
            htemp = htemp.nextNode;
        }
    }
}

/**
 * 测试用例
 * @author elon@elon33.com
 *
 */
public class LinkedList {
    public static void main(String[] args) {
        CLType node,head=null;
        CLType CL = new CLType();
        String key,findkey;
        Scanner input = new Scanner(System.in);
        System.out.println("链表测试:\n先输入链表中的数据,格式为:关键字 姓名 年龄 (键入0则结束)");
        do{
            DATA nodeData = new DATA();         // 构造新结点
            nodeData.key = input.next();
            if(nodeData.key.equals("0")){
                break;
            }else{
                nodeData.name = input.next();
                nodeData.age = input.nextInt();
                head = CL.CLAddEnd(head, nodeData);
            }
        }while(true);
        CL.CLAllNode(head);         // 遍历所有结点

        System.out.printf("\n演示插入结点,输入插入位置的关键字:");
        findkey = input.next();
        System.out.printf("\n输入插入结点的数据(关键字 姓名 年龄)");
        DATA nodeData = new DATA();         // 构造新结点
        nodeData.key = input.next();
        nodeData.name = input.next();
        nodeData.age = input.nextInt();     
        head = CL.CLInsertNode(head, findkey, nodeData);
        CL.CLAllNode(head);

        System.out.printf("\n演示删除结点,输入要删除的关键字:");

        key=input.next();
        int result = CL.CLDeleteNode(head, key);
        System.out.println(result==1?"删除结点成功":"删除结点失败");
        CL.CLAllNode(head);

        System.out.printf("\n演示在链表中查找,输入查找关键字:");

        key = input.next();
        node = CL.CLFindNode(head, key);
        if(node!=null){
            nodeData = node.nodeData;
            System.out.printf("关键字%s 对应的结点为(%s,%s,%d)\n",key,nodeData.key,nodeData.name,nodeData.age);
        }else{
            System.out.printf("在链表中未查找到关键字为%s的结点!\n",key);
        }
    }
}
数据结构-线性表-单链表 阅读详情

相关推荐

微信支付开发之平台给用户转账到零钱的功能

请求消息中应包含商家批次单号、转账名称、appid、转账总金额、转账总笔数、转账openid、收款用户姓名等信息。批次已受理成功,若发起批量转账的30分钟后,转账批次单仍处于该状态,可能原因是商户账户余额不足等。【转账场景ID】 该批次转账使用的转账场景,如不填写则使用商家的默认场景,如无默认场景可为空,可前往“商家转账到零钱-前往功能”中申请。【转账总笔数】 一个转账批次单最多发起一千笔转账。【商家批次单号】 商户系统内部的商家批次单号,要求此参数只能由数字、大小写字母组成,在商户系统内部唯一。

程序员weixin_sodomany的博客 3456

线性表的链接储存结构及实现

单链表 1 单链表的定义 单链表是用一组任意的存储单元来存放线性表的元素。存储单元可以连续,也可以不连续 为了正确的表示元素之间的逻辑关系,每个存储单元除了存储元素外 ,还需要存储后继元素的位置,这个地址信息用指针表示,称为指针;这两个元素组成了数据元素的存储映像,称为结点 也就是说节点有两个部分组成的 数据域 指针域 2 单链表结点c++实现 struct Node{ ...

邵光亮的博客 1376

深信服PT1-AF实验考试

深信服PT1-AF实验考试实验练习可以去深信服的在线实验平台(链接如下):深信服在线实验平台 (sangfor.com.cn)实验考试其实就是把所有的每一部分实验综合了起来以下内容仅做参考,不确保一样。

m0_72019240的博客 7128

【数据结构】线性表--链表

数据结构,链表,线性表

2401_85032912的博客 1147

x265探索与研究(四):如何编码视频?

如何编码视频?           本文介绍x265中的两种编码视频方法,一是采用命令行的方法;二是GUI的方式。   1、命令行的方法   (1)、第一种方式生成*.265格式的视频文件           第一种方式可以生成*.265格式的视频文件,对应的命令为: x265 --input-res 352x288 --fps 30 hall_cif_352x288_300.y

成长Bar的博客专栏 3938

Basilisk vs. STK:开源航天仿真工具在Windows上的实战体验与生态对比

本文对比了开源航天仿真工具Basilisk与商业软件STK在Windows平台上的实战体验与生态差异。从技术架构、安装配置、使用成本、功能覆盖、社区生态到适用场景,全面分析了二者的优劣势,为航天工程师和研究人员提供选型参考。Basilisk在性能和扩展性上表现突出,而STK在可视化与专业模块上更具优势。

weixin_30632089的博客 589

数据结构——线性表(链式存储结构)

链表的13种操作 实现思路和代码

qq_55869380的博客 6675

数字IC验证秋招真题的工程逻辑拆解

数字IC验证是芯片流片前保障功能正确性的核心环节,其本质在于用有限资源穷尽失效路径。它依托UVM等验证方法学,融合协议理解(如AMBA/AXI)、架构分析(如Cache一致性)与功能建模(如UART/DMA),通过随机约束、断言嵌入、覆盖率驱动和故障注入等技术实现高置信度验证。在工业实践中,验证工程师需将抽象协议转化为可观测信号行为,将笔试‘八股’还原为真实项目中的场景拆解、调试归因与策略权衡。本文聚焦秋招高频真题,揭示协议时序、一致性机制与模块故障背后的工程思维范式,帮助应届生跨越从语法记忆到验证落地的能

weixin_29173777的博客 175

数据结构与算法——线性表(链表篇)

本篇文章,主要详细解读和总结线性表的链式存储结构——链表,包括单链表、双链表、静态链表以及循环链表,讲解较为全面,图文并茂,总结各链表的特性以及基本操作,干货满满,各位小伙伴们请细细品读,你会收获你想要的知识的!.........

小田是个程序员的博客欢迎你的到来呀~ 2万+

游戏开发实战:用UE4 Marschner模型打造次世代头发渲染(附Shader代码解析)

本文详细解析了如何在UE4中使用Marschner模型实现次世代头发渲染,包括Shader代码逐行解读与参数调优。通过对比传统Kajiya-Kay模型,展示了Marschner模型在物理精确性和视觉效果上的优势,并提供了性能优化与实战技巧,帮助技术美术师提升游戏角色渲染品质。

weixin_28223453的博客 241

YOLOv8 交通违规检测各个场景的实际应用

本文介绍了基于YOLOv8的交通违规检测系统在不同场景下的应用实现。系统可检测闯红灯、超速、违停和不系安全带等多种违规行为,针对每种场景提供了具体的技术方案和Python实现代码。其中闯红灯检测结合信号灯状态分析,超速检测通过距离时间计算速度,违停检测采用长时间跟踪策略,安全带检测则需更高精度识别。文章还展示了如何整合各功能构建综合交通监管系统,并总结了不同应用场景的技术要点和优化方向,为智能交通管理提供了实用解决方案。

u010117029的博客 301

线性表的链式存储结构

线性表的链式存储结构

weixin_61898526的博客 1174

第14.11章 高翔博士最新开源框架Lightning-LM源码解读(十一):离线定位模块全解析,从激光匹配到位姿图优化的极致优化

本文介绍了Lightning-LM离线定位模块的技术架构与实现细节。该模块基于3D激光雷达与IMU融合,采用改进版NDT匹配算法实现高精度定位,具备动态图层更新、多源信息融合等特性。核心流程包括数据预处理、激光里程计处理、IMU预测与点云去畸变、位姿图优化等环节,通过轻量级miao库实现高效增量优化。文章详细解析了模块的代码结构、关键函数功能及数据流,为SLAM系统的开发与优化提供了实践参考。

行知SLAM 376

【数据结构——线性表之链表】

线性表之《链表的表示及基本操作的实现》 目录线性表之《链表的表示及基本操作的实现》一、单链表(一)单链表的描述(一)单链表的操作实现1、初始化2、查找3、插入4、删除二、循环链表三、循环链表 一、单链表 (一)单链表的描述 typedef struct LNode { ElemType data;//结点数据域 struct LNode* next;//结点指针域 }LNode ,*LinkList; 变量定义: LNode* p, * q LinkList L; p, q, L都是指针变量,

lflcodeplus的博客 2689

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

数据结构-一文吃透线性表中链表题目

1.链表不具有的特点是 ( A) A. 可随机访问任一元素 B. 插入删除不需要移动元素 C.不必事先估计存储空间 D.所需空间与线性表长度成正比 答案解析 [解析] 链表采用的是链式存储结构,它克服了顺序存储结构的缺点:它的接点空间可以动态申请和释放;它的数据元素的逻辑次序靠结点的指针来指示,不需要移动数据元素。但是链式存储结构也有不足之处:①每个结点中的指针域需额外占有存储空间;②链式存储结构是一种非随机存储结构。 2.设单链表中指针p指向A,若要删除A的后继结点,则需修改指针的操作为(p

呵呵哒!的博客 6242

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

数据结构之链表与线性表

数据结构之链表与线性表 线性表(顺序线性表) 顺序表(顺序线性表):使用数组实现,一组地址连续的存储单元,数组大小有两种方式指定,一是静态分配,二是动态扩展。 优点:随机访问特性,查找O(1)时间,存储密度高;逻辑上相邻的元素,物理上也相邻; 缺点:插入删除需移动大量元素。 只需要输入对应的位置即可取出,所以复杂度为O(1),即查找一个元素的时间复杂度为O(Length),而平均查找长度 AC...

NextCodemonster的博客 642

【数据结构与算法】之线性表:顺序表和链表个人总结

定义:线性表是具有相同特性的数据元素的一个有限序列。特点:各个数据元素之间是线性关系。在非空的线性表中,有且仅有一个开始结点,它没有直接前趋,而仅有一个直接后继。有且仅有一个终端结点,它没有直接后继,而仅有一个直接前趋。其余内部结点都有且仅有一个直接前趋和一个直接后继。

2201_75455144的博客 2190

26王道数据结构:线性表+链表

静态链表的存储空间是一整片的连续存储空间;但是在这一片空间内,逻辑上相邻的数据元素在物理上可能不相邻。各个元素之间的逻辑先后关系用游标值来表示;增加或者删除一个数据元素时,不需像顺序表那样大量的移动元素,只需修改相关节点的游标即可不支持随机存取,每次只能从头节点依次往后开始查找缺点:存储容量是固定的,只要你声明了一个静态链表,那么它所能存放的最大容量就已经被定死了。早期的一些不支持指针的低级语言会用静态链表,这样的方式实现和单链表同样的功能。适用场景:数据元素的数量几乎是固定不变的情况;

m0_73954830的博客 833

数据结构线性表之链表(详解)

1、什么是线性表 首先,线性表是一种数据结构,是一种数据在逻辑上是连续的结构。 其次,线性表在计算机内部可以用顺序结构和链式结构存储数据。 顺序结构可以采用数组的方式完成,而本文主要描述的就是链式的线性表 2、什么是链表 链表是一个十分抽象的名词,但是开发者可以将其和火车结合进行理解,每一节车厢就是一个节点,而车厢与车厢之间的连接就是节点和节点之间的连接,但是在程序世界并不存在车厢与车厢那种的实际连接,因为程序世界的构成是内存,学过C/C++的开发者都知道,内存与内存的关系就是指针指向,那么就很好理解

qq_45515182的博客 2008

线性表的静态链表存储结构

线性表的静态链表存储结构 头文件 1 //SLinkList.h 2 3 #ifndef SLINKLIST_H 4 #define SLINKLIST_H 5 6 #define MAXSIZE 1000 7 8 typedef char ElemType; 9 typedef struct { 10 ElemType dat...

dongken9651的博客 548

数据结构(4)线性表-链表-双链表

迟来的分类,主要如果在学习单链表前去讲分类,可能就云里雾里的,所以放在讲完单链表后讲。划分链表的标准如下:有没有头结点、指针的方向、循环与否头结点就是一个占位结点,也被叫做哨兵位,一般就是标识起点、防止链表为空,本身不储存任何有效元素(就类似于我们高速上看到的,前方多少米服务区,前方多少米进入什么地界,碰到头结点就知道遍历到链表的头结点了)。指针方向一个是只能从前往后遍历,另外一个双向的就是既有指向前一个结点的指针,也有指向后一个结点的指针。

2401_85751795的博客 1947

【数据结构】【线性表】链表

1 引言 链表是一种链式存储的线性表,所有元素的内存地址不一定是连续的。 2 接口 /** * @Description: 线性表接口 * @Auther: zhurongsheng * @Date: 2020/4/22 23:26 */ public interface ZrsList<E> { /** * 元素数量 */ int si...

qq_34125999的博客 1777

线性表的静态单链表存储结构

// c2-3.h 线性表的静态单链表存储结构(见图2.23) #define MAX_SIZE 100 // 链表的最大长度 typedef struct { ElemType data; int cur; }component,SLinkList[MAX_SIZE]; // algo2-7.cpp 教科书中图2.10静态链表示例 // 第1个结点的位置在[0].cur中。成员cur的值为0

a4647520的专栏 695

数据结构之线性表 顺序表 链表

1.线性表 线性表(linear list)是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构,常见的线性表:顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物 理上存储时,通常以数组和链式结构的形式存储。 2.顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据...

jackcode2的博客 291

线性表的链式存储结构 ( 链表 )

这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar

qq_59708493的博客 4797
上一篇: 线性表之顺序表结构
下一篇: 顺序栈结构
gamedev˚
博客等级 码龄12年 280粉丝 293原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值