精华内容
下载资源
问答
  • 链表结点插入

    2020-03-15 17:59:11
    师–链表结点插入 Description 给出一个只有头指针的链表和 n 次操作,每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表的元素总数则将x放在链表的最后。 Input 多组输入。每组数据首先输入一个...

    师–链表的结点插入

    Description

    给出一个只有头指针的链表和 n 次操作,每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表的元素总数则将x放在链表的最后。
    Input

    多组输入。每组数据首先输入一个整数n(n∈[1,100]),代表有n次操作。

    接下来的n行,每行有两个整数Mi(Mi∈[0,10000]),Xi。
    Output

    对于每组数据。从前到后输出链表的所有元素,两个元素之间用空格隔开。
    Sample
    Input
    4
    1 1
    1 2
    0 3
    100 4

    Output
    3 1 2 4

    Hint
    样例中第一次操作1 1,由于此时链表中没有元素,1>0,所以此时将第一个数据插入到链表的最后,也就是头指针的后面。

    第一种:

    #include <stdio.h>
    #include <stdlib.h>
    struct node
    {
        int data;
        struct node *next;
    };
    int main()
    {
        int n,m,x,i;
        struct node *head,*p;
        struct node *q;//定义新结点指针
        while(~scanf("%d",&n))
        {
            head=(struct node *)malloc(sizeof(struct node));
            head->next=NULL;
            for(i=0;i<n;i++)
            {
                p=head;
                scanf("%d %d",&m,&x);
                while(m--&&p->next)//找指针的位置
                    p=p->next;
                q=(struct node *)malloc(sizeof(struct node));//申请新结点空间;逆序建链表
                q->data=x;//给新结点赋值:为q结点赋值,数据域为关键字x,指针域为NULL
                q->next=NULL;
                q->next=p->next; //将p后面的结点链接到q的后面
                p->next=q;//将结点q链接到p的后面
            }
            p=head->next;
            while(p)
            {
                if(p->next==NULL)
                    printf("%d\n",p->data);
                else
                    printf("%d ",p->data);
                p=p->next;
            }
        }
        return 0;
    }
    
    

    链表结点的插入
    (1)开辟新结点:

    struct  node * q;  //定义新结点指针
    q=(struct node *) malloc (sizeof(struct node)); //申请新结点空间
    q->data=10;  //给新结点赋值
    q->next=NULL;
    

    在这里插入图片描述
    (2)修改指针域:
    q->next=p->next;
    p->next=q;
    在这里插入图片描述
    链表的查找:
    在这里插入图片描述###############*************###################
    第二种:

    #include <stdio.h>
    #include <stdlib.h>
    struct node
    {
        int a;
        struct node *next;
    };//定义结构体类型;
    void show(struct node *head)//链表输出函数;
    {
        struct node *p;
        p = head -> next;
        while(p)
        {
            if(p -> next)
            {
                printf("%d ",p -> a);
            }
            else printf("%d\n",p -> a);
            p = p -> next;
        }
    }
    int main()
    {
        struct node *head,*p;
        int n,i;
        int x;
        while(~scanf("%d",&n))
        {
            head = (struct node*)malloc(sizeof(struct node));
            //要多组输入,每一组输入都要重新开辟一个头结点;
            head -> next = NULL;
            for(i=0; i<n; i++)
            {
    
                p = (struct node*)malloc(sizeof(struct node));
                p -> next = NULL;
                scanf("%d%d",&x,&p -> a);
                struct node *q = head -> next;
                struct node *qi = head;//定义两个游动指针
                while(q&&x--)//寻找插入的位置;
                {
                    q = q -> next;
                    qi = qi -> next;
                }
                qi -> next = p;
                p -> next = q;//插入节点;
    
            }
            show(head);//输出链表;
        }
    
        return 0;
    }
    
    展开全文
  • 主要介绍了C语言实现带头结点链表的创建、查找、插入、删除操作方法,对于了解数据结构中链表的各项操作有很好的借鉴价值,需要的朋友可以参考下
  • 链表链表结点插入

    千次阅读 2018-03-17 13:00:42
    师–链表结点插入 Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Problem Description 给出一个只有头指针的链表和 n 次操作,每次操作为在链表的第 m 个元素后面插入一个新元素x。若m ...

    师–链表的结点插入

    Time Limit: 1000 ms Memory Limit: 65536 KiB

    Submit Statistic

    Problem Description

    给出一个只有头指针的链表和 n 次操作,每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表的元素总数则将x放在链表的最后。

    Input

    多组输入。每组数据首先输入一个整数n(n∈[1,100]),代表有n次操作。

    接下来的n行,每行有两个整数Mi(Mi∈[0,10000]),Xi。

    Output

    对于每组数据。从前到后输出链表的所有元素,两个元素之间用空格隔开。

    Sample Input

    4
    1 1
    1 2
    0 3
    100 4

    Sample Output

    3 1 2 4

    Hint

    #include <stdio.h>
    #include <stdlib.h>
    struct node
    {
        int data;
        struct node*next;
    };
    struct node*head;
    int len;
    void insert(int m,int x);
    void print();
    int main()
    {
        int n,i,m,x;
        while(~scanf("%d",&n))
        {   len=0;
        head=(struct node*)malloc(sizeof(struct node));
        head->next=NULL;
            for(i=0;i<n;i++)
            {
                scanf("%d %d",&m,&x);
                insert(m,x);
            }
            print();
        }
        return 0;
    }
    void insert(int m,int x)
    {
        struct node*p,*q;
        int i;
        p=head;
        for(i=0;i<m&&i<len;i++)
        {
            p=p->next;
        }//关键是这里,让指针跑到p的后面,在p的后面插上q
        q=(struct node*)malloc(sizeof(struct node));
        q->next=NULL;
        q->data=x;
        q->next=p->next;
        p->next=q;
        len++;
    }
    void print()
    {
        struct node*p;
        p=head->next;
        while(p)
        {
            if(p==head->next)
            {
                printf("%d",p->data);
            }
            else
            {
                printf(" %d",p->data);
            }
            p=p->next;
        }printf("\n");
    }
    
    展开全文
  • 目录 前期的链表有什么问题 怎么修改 如何测试 ...注意,只是在链表尾部插入结点时,省了些许时间,因为是单向链表,尾结点指针无法直接前移,要想在链表末尾删除节点时省些时间,只能通过双向

    目录

    前期的链表有什么问题

    怎么修改

    如何测试


    前期的链表有什么问题

    没有问题,但是不够好,最常用的操作在链表尾部添加结点,是通过查找链表末尾然后再插入的,用时较长。

    对于不是频繁在链表末尾 插入/删除操作,没什么影响。

    那有没有什么方式来完善呢?添加尾结点指针,可以更好的解决频繁插入问题。标记链表末尾,在链表末尾插入时就不必遍历链表来查找链表末尾所在位置了。

    注意,只是在链表尾部插入结点时,省了些许时间,因为是单向链表,尾结点指针无法直接前移,要想在链表末尾删除节点时省些时间,只能通过双向链表来实现了。

    源文件及测试文件我上传到CSDN上了:Add Tail Pointer LinkedList.zip

    怎么修改

    最先需要修改的是链表的定义,之后就是修改在链表尾部添加结点函数,再之后就是针对初始化、插入、删除、清空等涉及到结点数发生变化的 函数添加尾结点指针指向。

    typedef struct list
    {
        Node* head;             /* 指向链表头的指针 */
        Node* tail;             /* #TODO 指向尾结点的指针 */
        L_NUMBER_type items;         /* 链表中的项数 */
    }LinkedList;
    /**
     * LinkedListAddNode  #TODO
     * @brief   添加到链表尾部
     * @param   item 参数描述: 要写入结点的数据域
     * @param   plist 参数描述: 链表指针
     * @retval  true 返回值描述: 插入成功
     * @retval  false 返回值描述: 插入失败
     * @note    1.若链表已满,返回失败 2.新建结点,数据域复制到结点 3.将结点插入到链表 4.记录链表尾端的位置,链表结点数加1
     */
    bool LinkedListAddNode(Item item, LinkedList* plist)
    {
        Node* pnew;
        if(LinkedListIsFull(plist))
        {
            return false;                               /* 若链表已满,返回失败 */
        }
    
        pnew = (Node*)malloc(sizeof(Node));             /* 新建结点 */
        if(pnew == NULL)
        {
            printf("Unable to allocate memory! \n");
            exit(1);
        }
    
        CopyToNode(item, pnew);                         /* 结点初始化 */
        pnew->next = NULL;
    
        if(LinkedListIsEmpty(plist))                    /* 将结点插入到链表 */
        {
            plist->head = pnew;
        }else
        {
            plist->tail->next = pnew;      
        }
        plist->tail = pnew;                             /* 记录链表尾端的位置*/
        plist->items++;                                 /* 链表结点数加1 */
        return true;
    }
    /**
     * InitializeLinkedList
     * @brief   初始化链表
     * @param   plist 参数描述: 链表指针
     * @note    1.指针指向NULL 2.链表结点数为0
     */
    void 
    InitializeLinkedList(LinkedList* plist)
    {
        plist->head = NULL;         /* 指针指向NULL */
        plist->tail = NULL;         /* #TODO */
        plist->items = 0;           /* 链表结点数为0 */
    }
    
    /**
     * InsertNodeToLinkedList
     * @brief   
     * @param   plist 参数描述: 链表指针
     * @param   position 参数描述: 位置,取值范围: 0~plist->items
     * @param   item 参数描述: 结点数据域
     * @retval  true 返回值描述: 插入成功
     * @retval  false 返回值描述: 插入失败
     * @note    若链表已满,返回失败
     * @note    1. 若位置不可能插入到当前链表中,返回失败
     * @note    2. 若位置为0,创建一个结点,将数据域写入,该结点指向首结点,该结点成为新的首结点,链表结点数加1,返回成功
     * @note    3. 若为空链表,返回失败,否则 在要插入位置前一个结点停止,创建一个结点,将数据域写入,该结点指向位置前一个结点指向的结点,该结点成为对应位置处的结点,链表结点数加1,返回成功
     */
    bool InsertNodeToLinkedList(LinkedList* plist, L_NUMBER_type position, Item item)
    {
        Node* pnode = plist->head;
    
        if(LinkedListIsFull(plist))
        {
            return false;                                       /* 若链表已满,返回失败 #TODO */
        }
    
        if(position > plist->items)                             /* 等于plist->items时表示插入到链表尾部 */
        {
            return false;                                       /* 若位置不可能插入到当前链表中,返回失败 */
        }else if(position == 0)
        {
            Node* pnew = (Node*)malloc(sizeof(Node));           /* 创建一个结点 */
            if(pnew == NULL)
            {
                printf("Unable to allocate memory! \n");
                exit(1);
            }
            CopyToNode(item, pnew);                             /* 将数据域写入 */
            pnew->next = pnode;                                 /* 该结点指向首结点 */
            plist->head = pnew;                                 /* 该结点成为新的首结点 */
            if(position == plist->items)                        /* #TODO */
            {
                plist->tail = pnew;
            }
            plist->items++;                                     /* 链表结点数加1 */
    
            return true;                                        /* 返回成功 */
        }else
        {
            if(pnode == NULL)
            {
                return false;                                   /* 若插入位置不为0,且为空链表,返回失败  #TODO */
            }else
            {
                for(L_NUMBER_type i = 0; i < position-1; i++)        /* 在要插入位置前一个结点停止 */
                {
                    pnode = pnode->next;
                }
    
                Node* pnew = (Node*)malloc(sizeof(Node));       /* 创建一个结点 */
                if(pnew == NULL)
                {
                    printf("Unable to allocate memory! \n");
                    exit(1);
                }
                CopyToNode(item, pnew);                         /* 将数据域写入 */
                pnew->next = pnode->next;                       /* 该结点指向位置前一个结点指向的结点 */
                pnode->next = pnew;                             /* 该结点成为对应位置处的结点 */
                if(position == plist->items)                    /* #TODO */
                {
                    plist->tail = pnew;
                }
                plist->items++;                                 /* 链表结点数加1 */
    
                return true;                                    /* 返回成功 */
            }
        }
    }
    /**
     * DeleteNodeFromLinkedList
     * @brief   删除链表结点
     * @param   plist 参数描述: 链表指针
     * @param   position 参数描述: 位置,取值范围: 0~plist->items - 1
     * @param   pitem 参数描述: 删除结点的数据域
     * @retval  true 返回值描述: 删除成功
     * @retval  false 返回值描述: 删除失败
     * @note    1.位置为0:判断是否是空链表:是则返回失败,否则将修改链表 首结点前进到下一个结点,链表结点数减1
     * @note    2.位置不在当前链表内,返回失败
     * @note    3.在要删除位置前一个结点停止,将要删除的位置赋给结点指针,待删除结点的数据域通过指针返回,将删除位置前一个结点的指向删除位置后一个结点,链表结点数减1
     */
    bool DeleteNodeFromLinkedList(LinkedList* plist, L_NUMBER_type position, Item* pitem)
    {
        Node* pnode = plist->head;
    
        if(position == 0)
        {
            if(pnode == NULL)                           //if(DeleteNodeFromLinkedList(plist)) #TODO
            {
                return false;                           /* 是空链表,返回失败 */
            }else
            {
                plist->head = pnode->next;              /* 首结点前进到下一个结点 */
                
                if(position == (plist->items - 1))      /* #TODO */
                {
                    plist->tail = NULL;                 /* 此时plist->head 也指向NULL */
                }
    
                plist->items--;                         /* 链表结点数减1 */
                return true;
            }
        }else if(position >= plist->items)
        {
            return false;                               /* 位置不在当前链表内,返回失败 */
        }else
        {
            for(L_NUMBER_type i = 0; i < position-1; i++)    /* 在要删除位置前一个结点停止 */
            {
                pnode = pnode->next;
            }
    
            Node* pn = pnode->next;                     /* 将要删除的位置赋给结点指针 */
            CopyToItem(pn, pitem);                      /* 待删除结点的数据域通过指针返回 */
            pnode->next = pn->next;                     /* 将删除位置前一个结点的指向删除位置后一个结点 */
    
            if(position == (plist->items - 1))          /* #TODO */
            {
                plist->tail = pnode;
            }
            plist->items--;                             /* 链表结点数减1 */
    
            pn = NULL;
    
            return true;
        }
    }

    如何测试

    添加尾结点指针,真正目的就是链表尾部添加节点函数,首先测试它能否正常使用,接着测试对于进行插入、删除、清空操作后,尾结点指针是否正常指向链表末尾,链表尾部添加结点函数能否正常在链表尾部插入。通过遍历输出结点数据域的方法来调试观察。

    实际测试方式如下:

    测试代码如下:

    #include <stdio.h>      /* 调用printf 函数 */
    #include <time.h>       /* 调用time 函数 */
    #include <stdlib.h>     /* 调用srand rand 函数 */
    #include "LinkedList.h" /* 调用LinkedList的数据类型和操作函数 */
    
    
    #define DEBUG_OUTPUT    1
    #define TEST_TAIL_POINTER       1
    
    
    void test_Linked_List_Add(LinkedList* plist, uint8_t num)
    {
        Item temp_item;
        L_NUMBER_type temp_index;
    
        printf("*********START add linkedList to tail node*********** \n");
        for(uint8_t i=0; i<num; i++)
        {
            if(! LinkedListIsFull(plist))
            {
                temp_item = rand() % 256;
                printf("random_val is:  %d \n", temp_item);
                if (! LinkedListAddNode(temp_item, plist))
                {
                    printf("add to linkedList end error ! \n");
                }        
            }else
            {
                printf("Linked List is FULL, From %s \n", __FUNCTION__);
            }
        }
        ShowLinkedListNode(plist);
        temp_index = LinkedListNodeCount(plist);
        printf("*********FINISH added linkedList num is:  %d*********** \n\n", temp_index);
    }
    
    void test_Linked_List_Insert(LinkedList* plist, uint8_t num)
    {
        Item temp_item;
        L_NUMBER_type temp_index;
    
        printf("*********START insert linkedList to tail node*********** \n");
        for(uint8_t j=0; j<num; j++)
        {
            if(! LinkedListIsFull(plist))
            {
                temp_index = LinkedListNodeCount(plist);
                temp_item = rand()%256;
                printf("random_val is:  %d \n", temp_item);
                if (! InsertNodeToLinkedList(plist, temp_index, temp_item))
                {
                    printf("insert to linkedList error ! \n");
                }
            }else
            {
                printf("Linked List is FULL, From %s \n", __FUNCTION__);
            }
        }
        ShowLinkedListNode(plist);
        temp_index = LinkedListNodeCount(plist);
        printf("*********FINISH inserted linkedList num is:  %d*********** \n\n", temp_index);
    }
    
    void test_Linked_List_delete(LinkedList* plist, uint8_t num)
    {
        Item temp_item;
        L_NUMBER_type temp_index;
    
        printf("*********START delete tail node from linkedList*********** \n");
        for(uint8_t k=0; k<num; k++)
        {
            if(! LinkedListIsEmpty(plist))
            {
                temp_index = LinkedListNodeCount(plist);
                if (! DeleteNodeFromLinkedList(plist, temp_index - 1, &temp_item))
                {
                    printf("delete item from linkedList error! \n");
                }
            }else
            {
                printf("Linked List is empty, From %s \n", __FUNCTION__);
            }
        }
        ShowLinkedListNode(plist);
        temp_index = LinkedListNodeCount(plist);
        printf("*********FINISH deleted linkedList num is:  %d*********** \n\n", temp_index);
    }
    void test_Linked_List_Clear(LinkedList* plist)
    {
        printf("*********START empty the linkedList*********** \n");
        EmptyTheLinkedList(plist);      /* 若链表清空后会有打印 */
        ShowLinkedListNode(plist);      /* 若链表为空会有打印 */
        printf("*********FINISH empty the linkedList*********** \n\n");
    }
    int main(void)
    {
        LinkedList line;
        
    
        srand((unsigned)time(NULL));
        InitializeLinkedList(&line);
    #if TEST_TAIL_POINTER
    
        test_Linked_List_Add(&line, 3);
        
        test_Linked_List_Insert(&line, 3);
        test_Linked_List_Add(&line, 3);
    
        test_Linked_List_delete(&line, 5);
        test_Linked_List_Add(&line, 3);
    
        test_Linked_List_Clear(&line);
        test_Linked_List_Add(&line, 4);
    
        test_Linked_List_Clear(&line);
        test_Linked_List_Add(&line, 2);
        test_Linked_List_Add(&line, 3);
    
        test_Linked_List_Clear(&line);
    #else
    }

    展开全文
  • 链表-在链表尾部插入新节点

    千次阅读 2019-03-12 00:04:40
    //在链表尾部加入新节点 public class Node{ public int data; public Node next; public Node(int data){ this.data=data; } } public void addNode(int n){ Node newNode=new Node(n); if(...
    //在链表尾部加入新节点
    public class Node{
        public int data;
        public Node next;
        public Node(int data){
            this.data=data;
        }
    }
    public void addNode(int n){
        Node newNode=new Node(n);
        if(head==null){
            head=newNode;
            return;
        }
        Node tmp=head;
        while(tmp.next!=null){
            tmp=tmp.next;
        }
        tmp.next=newNode;
    }

     

    展开全文
  • /* ...*All rights reserved. ...*问题描述:向单向链表尾部插入节点,新增并提供打印功能 *输入描述:学生姓名 *程序输出:;。 *备注: */ #include <stdio.h> #include<string.h> #inclu...
  • 链表指定位置插入结点链表) 问题描述 : 输入若干(不超过100个)非负整数,创建一个不带头结点的单向链表。 再输入一个位置index以及一个数据data,程序中首先创建一个新结点s,s的数据成员为data,然后调用...
  • 链表插入结点算法

    2017-06-05 11:12:44
    链表结点插入算法
  • 1、头文件(.h) #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #define FALSE 0 #define TRUE 1 typedef int LinkData; typedef struct _node { LinkData data; struct _node * next;...// 创建链表 Node * Cre
  • Java 链表结点插入

    千次阅读 2018-05-01 15:18:48
    PS:链表是一种数据结构,而数据结构就是一种存放数据的方式。...但插入、删除慢,要往某个位置插入或删除一个人时,后面的人身上的编号都要变。当然,加入或删除的人始终末尾的也快。 2、链表就...
  • 链表——师--链表结点插入

    千次阅读 2018-08-11 10:55:42
    师–链表结点插入 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 给出一个只有头指针的链表和 n 次操作,每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表的元素总数...
  • 使用C语言实现了单向链表的创建,输出,插入元素和删除元素以及单向链表的逆序连接和两个有序线性表的归并
  • 个人编写的在链表的第i个结点插入结点的C语言源码
  • 用C语言写出带头结点链表那些带头结点链表的题目必要代码定义一个结构体创建一个带头结点的单链表 今天有一位学弟在网上向我吐血求助,让我帮他写c语言带头结点链表题目。 我想了想,c语言我有一年半载没有...
  • 以下为“链表头部插入新节点”的简单示例: 1. 用c语言实现的版本为: #include #include typedef char datatype; typedef struct node{ datatype data; struct node *next; } listnode; typedef listnode *...
  • 一、创建链表 1、第一种创建链表的方法,注意对比和第二种创建链表的细微之处, typedef struct mynode { int num; float score; struct mynode * next; }Node,* Pnode; Pnode createList() { Pnode head,...
  • 双向链表结点插入和删除算法

    万次阅读 多人点赞 2018-10-03 23:47:46
    双向链表插入与删除 双向链表结点定义 #define ElemType int //双向链表的存储结构 typedef struct DuLNode ...双向链表结点删除 ...画图表示,并在上述双向链表中一个已知结点p之后插入一个结...
  • Description 编写一个函数creatlink,用来建立一个动态链表。(包含学号和成绩) 编写一个函数printlink...编写一个函数insertlink,用来向动态链表插入一个结点。 编写一个函数freelink,用来释放一个动态链表。 In
  • 我们应该先要将即将断开部分的前后连接保存下来,也就是链表插入的第一步,将new的后继指向原始链表的中P的下一个结点。然后,将new的前驱指向P结点,这样就保证了链表的前后部分不丢失。然后是第三步,将P结点的...
  • 链表指定位置插入结点

    千次阅读 2020-07-01 14:53:36
    链表指定位置插入结点 问题描述: 输入若干(不超过100个)非负整数,创建一个不带头结点的单向链表。 再输入一个位置index以及一个数据data,程序中首先创建一个新结点s,s的数据成员为data,然后调用函数insert...
  • 使用给定数据结构,实现带头结点的单向链表的创建、删除链表插入结点等操作,每个学生的学号互不相同,学号不同而姓名相同则为不同的学生,每个学生的学号在合并后的链表中不重复,如果出现重复,则删除年龄较小...
  • 这篇文章主要介绍了C语言实现带头结点链表的创建、查找、插入、删除操作方法,对于了解数据结构中链表的各项操作有很好的借鉴价值,需要的朋友可以参考下 本文实例讲述了C语言实现带头结点链表的创建、查找、插入...
  • 从前面的HashMap和ConcurrentHashMap的源码分析我们可以得知,其内部的数据结构都用到了链表,所以,对链表的深入掌握非常有必要。本文将重点介绍单链表数据结构,然后通过代码实现单链表的头插法和尾插法。 单链表...
  • 最近在学习数据结构,对链表的理解也...插入/删除第一个存储数据的结点比较方便。 空表和非空表的操作比较统一。 对带头结点链表进行以下的处理 带头结点与不带头结点的操作相类似,只是在考虑是否为空表...
  • 数据结构-基本算法-不带头结点的循环链表(学生时代源码,调试可运行)
  • 在双向链表插入一个结点,注释非常详细!适合菜鸟。网上下载的,觉得不错,和大家分享。
  • 给定索引index ,数据元素x,将x插入到index的位置。 C++:设计一个结构体struct chainNode,再设计一个具体类 class doubleChain 作为抽象类 class linearList的派生类实现类linearList中的所有方法,外加实现双向...
  • 双向链表实现结点

    2018-04-11 08:47:19
    定义、实现并测试一个双向链表结点类DNode。...编写主程序:输入不少于3组x、y整数,分别利用左侧和右侧插入结点函数组织数据为双向链表,测试输出链表中每个结点的左侧和右侧相邻节点内容,测试对左右侧结点的删除。
  • C\C++之用结构体实现链表的创建、遍历、结点插入、结点删除 叮嘟!这里是小啊呜的学习课程资料整理。好记性不如烂笔头,今天也是努力进步的一天。一起加油进阶吧!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 119,749
精华内容 47,899
关键字:

结点的插入链表