“仿制”链表，做一个属于自己的链表

最新推荐文章于 2026-01-04 20:56:17 发布
原创 最新推荐文章于 2026-01-04 20:56:17 发布 · 132 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构

链表的初始化

1.对于链表的初始化，首先你得有一个链表，然后进行初始化链表的数据域和指针域，再一个要有一个构造方法对链表的数据进行赋值。
在这里插入图片描述
2.再这里我创建三个Java Class, 第一个就是具体操作的代码类，MySingleLinkedList ，第二个就是这个类的Test类 Test_MySingleLinkedList 用于对各个操作进行执行和检验，第三个就是对其中一个操作的补充 自定义异常类 ListIndexOutOfException。
3.下面是初始化链表的代码实现

public class MySingleLinkedList {
    static class ListNode{
        public int val;   //数据域
        public ListNode next;  //指针域
        public ListNode(int val){    //构造方法（对链表进行初始赋值）
            this.val = val;
        }
    }
    public ListNode head;  // 头结点

链表的创建

既然链表的东西都有了，那么我们就可以创建一个链表以便于对以后操作的实现。

    //创建链表
    public void createLink() {
        ListNode listNode1 = new ListNode(88);  //进行实例化赋值
        ListNode listNode2 = new ListNode(7);
        ListNode listNode3 = new ListNode(15);
        ListNode listNode4 = new ListNode(29);
        ListNode listNode5 = new ListNode(16);
        head = listNode1;     //将链表的头结点地址记录下来
        listNode1.next = listNode2;  //将每一个结点连接起来成为链表
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        listNode4.next = listNode5;
        listNode5.next = null;   //最后的地址置空
    }

在这里插入图片描述

特别注意（对于next的说明）：

在这里插入图片描述

遍历链表

将链表展示出来，由于单链表是单向移动的，所以要定义一个结点，让它来进行移动，若不进行这样操作链表就会缺失。
在这里插入图片描述
如上图，再次执行别的操作就无法知道前面的结点了。

实质

遍历链表其实就是将cur一直向后面走，直到它为空为止。

    //遍历链表
    public void display(){
        ListNode cur;
        cur = head;
        while (cur != null){     //注意此处cur和cur.next的区别
            System.out.print(cur.val+" ");   //注意此处cur.val和cur.next.val的区别
            cur = cur.next;
        }
        System.out.println();
    }

注意：cur != null 和 cur.next != null 是不一样的，当两者循环执行到末尾时，如下图
在这里插入图片描述

public class Test_MySingleLinkedList {
    public static void main(String[] args) {
        MySingleLinkedList mySingleLinkedList = new MySingleLinkedList();
        mySingleLinkedList.createLink();         //创建链表
        mySingleLinkedList.display();          //遍历链表

在这里插入图片描述

指定位置输出链表

从指定位置输出链表其实就是将遍历这个方法重写，给这个方法设定一个参数newhead，将newhead给cur，让cur遍历即可。

     // 从指定位置开始打印链表
    public void display(ListNode newHead) {     //进行display方法的重写
        ListNode cur;
        cur = newHead;         //将指定位置传给cur
        while (cur != null){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }

在此处，newhead在Test这个类中应被赋予新的位置（即指定的位置），例如：newhead = listNode3; newhead = listNode4; 等等。

查找关键字key是否在链表中

在这里插入图片描述

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur = head;
        while (cur != null){
            if(cur.val == key){
                return true;
            }else {
                cur = cur.next;
            }
        }
        return false;
    }

计算链表的长度

链表的长度计算就是将链表进行遍历，在遍历过程中设置一个计算器即可（cunt），若链表不为空，则cunt++; cur向后面移动，直到cur为空为止并返回cunt。注意当cur == null；即链表为空，则return 0;

    //计算单链表的长度
    public int size(){
        ListNode cur = head;
        int count = 0;
        if(cur == null){
            return 0;
        }
        while (cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }

在测试类中进行测试：

        //查找是否包含关键字key是否在单链表当中
        boolean ret = mySingleLinkedList.contains(15);
        System.out.println(ret);
        System.out.println("=======================");
        //计算单链表的长度
        int ret1 = mySingleLinkedList.size();
        System.out.println(ret1);
        System.out.println("=======================");

在这里插入图片描述

头插

对于头插法，首先要创建一个待插入的结点，然后只需调整head和结点的指针域。
在这里插入图片描述

    //头插法
    public void addFirst(int data){
        ListNode listNode = new ListNode(data);  //新建一个列表，赋值为data
        listNode.next = head;
        head = listNode;
    }

在此不需要判断链表是否为空，当链表为空的时候不影响代码和最后的结果。

尾插

尾插法，首先创建一个待插入结点，那么要进行插入，要找到这个链表的尾巴，然后才能插入。将创建的这个结点的地址给到链表尾巴结点的指针域，这样就连接起来了。注意当链表为空时，只需将创建结点的地址给head即可。
在这里插入图片描述

    //尾插法
    public void addLast(int data){
        ListNode listNode = new ListNode(data);
        ListNode cur = head;
        if (cur == null){    //链表为空
            cur = listNode;
            return;
        }
        while (cur.next != null){   //首先要找到尾
            cur = cur.next;
        }
        cur.next = listNode;
        listNode.next = null;
    }

任意位置插入

1.创建待插入结点，检验插入的位置(index)是否合法。
2.若插入位置为0(链表为空一个道理)，则为头插，调用方法
3.若插入位置为链表长度size(),则为尾插，调用尾插
4.当为链表中间位置时，找到插入位置的前一个结点(因为是单链表，无法向前移动)
5.将 ListNode.next == cur.next; 将cur.next == ListNode
6.在此我将判断位置是否合法，寻找index的前一个结点分别写了两个方法，若对于插入位置不合法我使用异常来处理，单独创建了一个异常类
在这里插入图片描述
在这里插入图片描述

    //任意位置插入（第一个结点的下标为0）
    public void addIndex(int index,int data){
        checkIndex(index);     //检验是否合法
        ListNode listNode = new ListNode(data);
        if(index == 0){   //前插
            addFirst(data);
            return;
        }
        if(index == size()){       //尾插
            addLast(data);
            return;
        }
        ListNode cur = FindIndex(index);  //查找index位置
        listNode.next = cur.next;
        cur.next = listNode;
    }

    //检验插入位置是否合法
    private void checkIndex(int index){
        if(index<0 || index>size()){ //当位置小于0，位置超出链表大写，报异常
            throw new ListIndexOutOfException("位置不合法");
        }
    }

    //查找index-1位置
    private ListNode FindIndex(int index){
        ListNode cur = head;
        int count = 0;
        while (count != index-1 ){      //此处注意要找到插入位置的前一个结点
            cur = cur.next;
            count++;
        }
        return cur;
    }

public class ListIndexOutOfException extends RuntimeException {  //自定义异常类
    public ListIndexOutOfException(String message) {
        super(message);
    }
}

现在来对头插 尾插 任意位置插入进行测试：

        //头插法
        mySingleLinkedList.addFirst(31);
        mySingleLinkedList.display();
        System.out.println("========上面为头插===============");
        //尾插法
        mySingleLinkedList.addLast(41);
        mySingleLinkedList.display();
        System.out.println("=========上面为尾插===============");
        //任意位置插入
        mySingleLinkedList.addIndex(2,51);
        mySingleLinkedList.display();
        System.out.println("===========上面为任意位置插入=========");

在这里插入图片描述

删除第一个为key的结点

1.若链表为空，返回
2.若链表的头结点就是key，只需将head向后移
3. 若key在1,2点以外的位置，首先要找到key的前一个结点（还是由于单链表，无法向前移），然后将cur.next = cur.next.next; 即可。
在这里插入图片描述

    //删除第一个为key的结点
    public void remove(int key){
        if (head == null){
            return;
        }
        if(head.val == key){
            head = head.next;   //注意此处头结点是head，永远以head为链表的开端，若使用cur即链表开端还是head，无法删除链表的头结点
            return;
        }
        ListNode cur1 = FindPrev(key);
        if(cur1 == null){
            return;
        }
        cur1.next = cur1.next.next;
    }
    //寻找key的位置（找到前一个结点）
    private ListNode FindPrev(int key){
        ListNode cur = head;
        while (cur != null){
            if(cur.next.val == key){
                return cur;        //找到了
            }
            cur = cur.next;
        }
        return null;   //链表中无key值
    }

        //任意位置插入
        mySingleLinkedList.addIndex(2,51);
        mySingleLinkedList.display();
        System.out.println("===========上面为任意位置插入=========");
        ////删除第一次出现关键字为key的节点
        mySingleLinkedList.remove(88);
        mySingleLinkedList.display();
        System.out.println("========================");

在这里插入图片描述

删除所有为key的结点

1.要删除所有为key的结点显然一个指针是不够的，采用双指针法，prev和cur
在这里插入图片描述

2.若链表为空，返回即可
3.若cur.val为key，就删除，将cur.next 赋给 prev.next, cur向后走
在这里插入图片描述
4.若不是prev和cur一起往后走 prev = cur; cur = cur.next;
在这里插入图片描述
5.若头结点就是key，只需将head后移
在这里插入图片描述

    //删除链表中所有为key的结点
    public void removeAllKey(int key){
        if(head == null) {
            return;
        }
        ListNode prev = head;
        ListNode cur = head.next;
        while (cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val == key) {
            head = head.next;
        }
    }

        //删除链表中所有为key的结点
        mySingleLinkedList.removeAllKey(31);
        mySingleLinkedList.display();
        System.out.println("=========================");

清空链表（回收所有结点）

将头置空

    // 回收所有结点
    public void clear() {
        head = null;
    }

整体实现

1.操作类

public class MySingleLinkedList {
     static class ListNode{
        public int val;   //数据域
        public ListNode next;  //指针域
        public ListNode(int val){
            this.val = val;
        }
    }
    public ListNode head;  // 头结点

    //创建链表
    public void createLink() {
        ListNode listNode1 = new ListNode(88);
        ListNode listNode2 = new ListNode(7);
        ListNode listNode3 = new ListNode(15);
        ListNode listNode4 = new ListNode(29);
        ListNode listNode5 = new ListNode(16);
        head = listNode1;
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        listNode4.next = listNode5;
        listNode5.next = null;
    }
    //遍历链表
    public void display(){
        ListNode cur;
        cur = head;
        while (cur != null){     //注意此处cur和cur.next的区别
            System.out.print(cur.val+" ");   //注意此处cur.val和cur.next.val的区别
            cur = cur.next;
        }
        System.out.println();
    }

     // 指定位置输出链表
    public void display(ListNode newHead) {
        ListNode cur;
        cur = newHead;
        while (cur != null){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }

    //链表是否存在key
    public boolean contains(int key){
        ListNode cur = head;
        while (cur != null){
            if(cur.val == key){
                return true;
            }else {
                cur = cur.next;
            }
        }
        return false;
    }
    //计算单链表的长度
    public int size(){
        ListNode cur = head;
        int count = 0;
        if(cur == null){
            return 0;
        }
        while (cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }
    //头插法
    public void addFirst(int data){
        ListNode listNode = new ListNode(data);  //新建一个列表，赋值为data
        listNode.next = head;
        head = listNode;
    }
    //尾插法
    public void addLast(int data){
        ListNode listNode = new ListNode(data);
        ListNode cur = head;
        if (cur == null){
            cur = listNode;
            return;
        }
        while (cur.next != null){   //首先要找到尾
            cur = cur.next;
        }
        cur.next = listNode;
        listNode.next = null;
    }
    //任意位置插入,第一个结点下标为0
    public void addIndex(int index,int data){
        checkIndex(index);     //检验是否合法
        ListNode listNode = new ListNode(data);
        if(index == 0){   //前插
            addFirst(data);
            return;
        }
        if(index == size()){       //尾插
            addLast(data);
            return;
        }
        ListNode cur = FindIndex(index);  //查找index位置
        listNode.next = cur.next;
        cur.next = listNode;
    }
    //检验插入位置是否合法
    private void checkIndex(int index){
        if(index<0 || index>size()){
            throw new ListIndexOutOfException("位置不合法");
        }
    }
    //查找index位置 （找到前一个结点）
    private ListNode FindIndex(int index){
        ListNode cur = head;
        int count = 0;
        while (count != index-1 ){      //此处注意要找到插入位置的前一个结点
            cur = cur.next;
            count++;
        }
        return cur;
    }
    //删除第一个为key的结点
    public void remove(int key){
        if (head == null){
            return;
        }
        if(head.val == key){
            head = head.next;   //注意此处头结点是head，永远以head为链表的开端，若使用cur即链表开端还是head，无法删除链表的头结点
            return;
        }
        ListNode cur1 = FindPrev(key);
        if(cur1 == null){
            return;
        }
        cur1.next = cur1.next.next;
    }
    //寻找key的位置（找到前一个结点）
    private ListNode FindPrev(int key){
        ListNode cur = head;
        while (cur != null){
            if(cur.next.val == key){
                return cur;        //找到了
            }
            cur = cur.next;
        }
        return null;   //链表中无key值
    }
    //删除链表中所有为key的结点
    public void removeAllKey(int key){
        if(head == null) {
            return;
        }
        ListNode prev = head;
        ListNode cur = head.next;
        while (cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val == key) {
            head = head.next;
        }
    }
    // 回收所有结点
    public void clear() {
        head = null;
    }
}

2.测试类

public class Test_MySingleLinkedList {
    public static void main(String[] args) {
        MySingleLinkedList mySingleLinkedList = new MySingleLinkedList();
        mySingleLinkedList.createLink();         //创建链表
        mySingleLinkedList.display();          //遍历链表
        //查找是否包含关键字key是否在单链表当中
        boolean ret = mySingleLinkedList.contains(15);
        System.out.println(ret);
        System.out.println("=======================");
        //计算单链表的长度
        int ret1 = mySingleLinkedList.size();
        System.out.println(ret1);
        System.out.println("=======================");
        //头插法
        mySingleLinkedList.addFirst(31);
        mySingleLinkedList.display();
        System.out.println("========上面为头插===============");
        //尾插法
        mySingleLinkedList.addLast(41);
        mySingleLinkedList.display();
        System.out.println("=========上面为尾插===============");
        //任意位置插入
        mySingleLinkedList.addIndex(2,51);
        mySingleLinkedList.display();
        System.out.println("===========上面为任意位置插入=========");
        ////删除第一次出现关键字为key的节点
        mySingleLinkedList.remove(88);
        mySingleLinkedList.display();
        System.out.println("========================");
        //删除链表中所有为key的结点
        mySingleLinkedList.removeAllKey(31);
        mySingleLinkedList.display();
        System.out.println("=========================");
        //回收全部结点
        mySingleLinkedList.clear();
        mySingleLinkedList.display();
        System.out.println("----------------");
    }
}

3.自定义异常类

public class ListIndexOutOfException extends RuntimeException {
    public ListIndexOutOfException(String message) {
        super(message);
    }
}

4.运行结果
在这里插入图片描述

王道计算机考研408计算机组成原理汇总（下）
qq_56012214的博客
06-13 1189
真正的英雄是明白世界的残酷，也遭受了社会带给他的苦难，他依然能用心的说“我热爱这个世界，我愿竭尽所能去为我的世界而好好战斗
夏令营复习准备
qq_32769481的博客
11-21 5866
文章目录算法学习资源数据结构交大计算机题目数学高等数学**离散数学**概率论线性代数逻辑推理题科研经历AI人工智能机器学习的现状和未来机器学习软件工程软件工程软件测试计算机基础操作系统数据库计算机网络计算机组成原理编译原理云计算英语阅读能力写作能力英文面试问题项目项目问题个人情况资料简历个人陈述学校LAMDA材料申请和lamda面试夏令营机试面试资料撰写交大计算机北大cha院北大信科资源计算机各种...
[C语言]从键盘输入一个长度为 n 的数组，用这个数组组成一个链表，并顺序输出链表每个节点的值。
t_r_ap的博客
08-14 1218
【代码】[C语言]从键盘输入一个长度为 n 的数组，用这个数组组成一个链表，并顺序输出链表每个节点的值。
求链表的倒数第m个元素
hello
03-24 1281
求链表的倒数第m个元素
问题 D: 案例3-1.3：求链表的倒数第m个元素（附加代码模式）
weixin_65908362的博客
10-04 732
本题是附加代码模式，主函数main的代码会自动附加在同学们提交的代码后面，请同学们在提交的时候注释掉自己的main函数。给你一个链表，链表长度为n，链表内各元素为a1，a2....an，给你一个数m，求链表倒数第m个数是多少。第二行：n个数字，为链表元素从头到尾依次排列。第一行：链表长度n（1
Java deque 双向队列
Yuanxuan的博客
05-15 761
操作 插入元素 addFirst():向队头插入元素，如果元素为空，则发生NPE addLast():向队尾插入元素，如果为空，则发生NPE offerFirst():向队头插入元素，如果插入成功返回true，否则返回false offerLast():向队尾插入元素，如果插入成功返回true，否则返回false 移除元素 removeFirst():返回并移除队头元素，如果该元素是null，则发生NoSuchElementException ...
C语言中求链表长度,链表长度为啥输出为0，求大神们给个解释，非常感谢
weixin_39874795的博客
05-21 251
该楼层疑似违规已被系统折叠隐藏此楼查看此楼# include # include # include typedef struct node{int data;struct node * pNext;}NODE,*PNODE;PNODE creatlist(void);void traverse(PNODE);bool empty(PNODE);int length(PNODE);int mai...
手写纯链表实现简易实时操作系统
Simple-Beauty的博客
07-09 410
首先查找资料，发现没有这种写法，要不就是跑裸机，把各个外设初始化，然后进入while1中，执行各种计算，这是裸机系统，更高级一点的是使用了内部中断与外部中断，进行pc跳转，进入中断，返回的while1继续执行后续循环。 但是，这样的程序while中的逻辑与每个指令的调用次数的相同的，若有些计算不需要那么多的计算次数，而有些需要多次计算呢，解决办法是有的，有人会说，使用定时器中断啊，这确实是一个办法，但这种方式进行指针跳转，消耗的时间比较多，中断更适合进行一些flag标志类的触发条件，而系统大多是时间还是在w
从面试官的角度分享一些后端校招经验
热门推荐
JavaGuide
07-01 1万+
1. 写在前面 我从去年年初开始在美团当校招面试官，参加了 17 届春招和 18 届秋招两届面试，总共就面试了五十多个人。本来我也就是刚开始学着当面试官，不该妄谈经验，但是因为最近换了一份工作，未来几年都不会再有国内互联网公司的校招经验了，所以不如趁热分享一下，省得知识过期。本文是个人体会，而且经验不多，读者姑妄听之就好，不必太认真。 这篇文章主要针对的是徘徊在 offer 线上下的同学，...
Henry手记—.NET数据结构对象补遗之单链表（一）
zgqtxwd的专栏
04-24 356
<!--google_ad_client = "pub-2947489232296736";/* 728x15, 创建于 08-4-23MSDN */google_ad_slot = "3624277373";google_ad_width = 728;google_ad_height = 15;//--><script type="text/javascript"
【艾琪出品】《计算机应用基础》【试题汇总9】
加油
01-12 4702
【声明】本博客内容，若有侵权请告之,会删除 非商业用途,如有侵权,请告知我,我会删除 很希望通过优快云这个平台与大家交流，如回复不及时，或不懂的请加我island68注明来自优快云 电子科技大学-电子科技大学《计算机系统结构》20秋期末考试 1. 下列不属于段式管理虚地址的组成部分的是（ ）。 A 基号 B 段号 C 虚页号 D 段内位移 2. 从流水线中个功能段之间是否有反馈回路的角度，可把流水线分为（ ）。 A 静态流水线和动态流水线 B 标量流水线和向量流水线 C 单功能流...
操作系统整理
@龙猫的博客
11-15 1036
1、操作系统概述 1.1、操作系统的概念、特征、功能和结构 1、操作系统的概念 在信息化时代，软件被称为计算机系统的灵魂。而作为软件核心的操作系统，已经与现代计算机系统密不可分、融为一体。计算机系统自下而上可粗分为四个部分：硬件、操作系统、应用程序和用户。操作系统管理各种计算机硬件，为应用程序提供基础，并充当计算机硬件和用户的中介。 硬件，如中央处理器、内存、输入输出设备等，提供了基本的计算资源。应用程序，如字处理程序、电子制表软件、编译器、网络浏览器等，规定了按何种方式使用这些资源来解决用户的计算问题
基于纯C语言实现的微信打飞机游戏源码与资源
本资源“纯C版的微信打飞机游戏”是一个使用C语言实现的经典飞行射击类小游戏，其灵感来源于微信平台早期推出的“打飞机”游戏。该游戏无需依赖任何图形游戏引擎，完全使用标准C语言结合Windows图形设备接口（GDI）...
数据结构 b+树
似流水般平静而坚定。
12-30 312
本文实现了一个B+树数据结构，包含完整的插入、删除、查找和范围查询功能。B+树采用M阶结构（示例中M=4），具有以下特点：1) 内部节点存储索引关键字；2) 叶子节点通过链表连接便于范围查询；3) 支持数据指针存储。核心算法包括节点分裂/合并处理上溢/下溢情况，通过递归调整保持树平衡。实现提供了详细的API接口，包括初始化、插入、删除、查找、范围查询和销毁操作，并包含调试显示功能。该实现采用C语言编写，使用动态内存管理，通过断言检查参数有效性，确保数据结构的正确性和健壮性。
【C语言】堆(Heap)的数据结构与实现：从构建到应用
qq_67169366的博客
01-04 680
结构特性：堆是一棵完全二叉树，意味着除了最后一层，其他层都是满的，且最后一层的节点都靠左排列顺序特性大根堆：父节点的值 ≥ 子节点的值小根堆：父节点的值 ≤ 子节点的值堆顶特性：堆顶元素（根节点）是整个堆中的极值元素操作时间复杂度说明插入O(log n)向上调整删除堆顶O(log n)向下调整获取堆顶O(1)直接访问建堆O(n log n)逐个插入优化建堆O(n)Floyd算法堆排序O(n log n)所有元素出堆。
十大经典排序算法详解（附C语言实现+复杂度分析）
weixin_44977283的博客
01-04 553
本文系统介绍了十大经典排序算法，包括冒泡排序、选择排序、插入排序等基础算法，以及希尔排序、快速排序、归并排序等进阶算法。详细解析了各算法的原理、C语言实现、时间/空间复杂度及稳定性特点，并提供了可直接运行的代码示例。特别对线性时间排序算法（桶排序、计数排序、基数排序）进行了深入讲解。最后总结各算法的适用场景，建议小规模数据使用基础排序，大规模数据选择快速排序或归并排序，特定场景考虑线性时间排序。所有代码均经过验证，可通过调整比较逻辑实现升序或降序排列。
数据结构——二叉树
吴声子夜歌的博客
12-29 786
如果一棵树中的每个结点有0、1或者2个孩子结点，那么这棵树就称为二叉树。空树也是一棵有效的二叉树。一棵二叉树可以看作由根结点和两棵不相交的子树（分别称为左子树和右子树)组成。如下图所示。严格二叉树：二叉树中的每个节点要么有两个孩子节点，要么没有孩子节点。满二叉树：二叉树中的每个节点恰好有两个孩子节点且所有叶子节点都在同一层。 完全二叉树：在定义完全二叉树之前，假定二叉树的高度为h。对于完全二叉树，如果将所有结点从根结点开始从左至右，从上至下，依次编号（假定根结点的编号为1），那么将得到从1~n(n为结点总数
408真题解析-2009-10-数据结构-排序
最新发布
tobias的博客
01-04 316
摘要：本文分析2009年一道排序算法选择题，题目要求根据第二趟排序结果反推所用算法。通过排除法：冒泡和选择排序会固定极值位置（不符合），二路归并排序第二趟应有4元素有序段（不符合），最终确定是插入排序（前3个元素有序）。总结各排序算法"趟"的特征：插入排序前k+1个有序，冒泡排序末尾k个有序，选择排序前k个有序，归并排序每2^k个元素有序。答案为B（插入排序）。
【C++】JSON核心数据结构解析及JSONCPP使用
Ape's IT Blog
01-04 690
JSON是一种轻量级数据交换格式，基于键值对组织数据，支持字符串、数字、布尔值、null等基础类型，以及对象和数组两种复合结构。JSON对象是无序键值对集合，数组是有序值列表。实际应用中常组合使用对象和数组表示复杂数据，如列表型数据和多层级结构。JSON语法严格，要求键必须用双引号、末尾不能有多余逗号。JsonCpp是C++的JSON处理库，核心类Json::Value可表示所有JSON数据类型，通过类型枚举区分不同结构。JSON广泛应用于前后端交互和数据存储，是跨平台数据交换的首选格式。
链表实现一元稀疏多项式的加减算法
在计算机科学中，处理这类问题时，链表数据结构是一个非常有效的方式，因为它能够很好地处理稀疏数据。链表允许我们动态地存储只有必要存储的数据，而不需要像数组那样预先分配一个固定大小的空间，从而在内存使用上...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值