链表经典题目（上）以及双向链表的增删改查

最新推荐文章于 2023-04-01 13:35:56 发布
最新推荐文章于 2023-04-01 13:35:56 发布
阅读量281 收藏 1
点赞数 3
分类专栏： C语言 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/txh1873749380/article/details/127660443
版权

 

 力扣链接

206. 反转链表 - 力扣（LeetCode）

自己的效率较低的思路，看看即可

struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode* cur=head;
    struct ListNode* tail=head;//追踪倒数第二个节点,快慢指针法
    struct ListNode* Newhead=head;
       if(head==NULL)
       {
          return head;
       }
       if(head->next==NULL)
       {
           return head;
       }
    while(cur->next!=NULL)
    {
        tail=cur;
        cur=cur->next;
    }
    tail->next=NULL;
    Newhead=cur;//记录新节点
    struct ListNode* CunNewhead=Newhead;//不让新节点改变
     while(head->next!=NULL)
     {
      cur=head;
       while(cur->next!=NULL)
       {
          tail=cur;
          cur=cur->next;
       }
       tail->next=NULL;
       CunNewhead->next=cur;
       CunNewhead=cur;
     }
     CunNewhead->next=head;
    return Newhead;
}

经典解法

struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode* cur=head;
    struct ListNode* prev=NULL;
    struct ListNode* tmp=NULL;
  while(cur) 
  {
       tmp=cur->next;
       cur->next=prev;
       prev=cur;
       cur=tmp;
  }
  cur=prev;
  return cur;
}

 

 83. 删除排序链表中的重复元素 - 力扣（LeetCode）

struct ListNode* deleteDuplicates(struct ListNode* head){
    if(head==NULL) return head;
//仔细看题是已排序过的
        struct ListNode* slow=head;
        struct ListNode* fast=head->next;
        struct ListNode* tail;
        while(fast)//暴力解法（双指针），
        {//每次迭代时，慢指针跟快指针先比较
         //如果相等，快指针继续走
         //直到快指针走到NULL,因为快指针肯定先走完
           if(slow->val==fast->val)//如果相等，就把值相等的节点释放
           //然后重新链接
           {
               tail=fast;
               fast=fast->next;
               slow->next=fast;
               free(tail);
           }
           else//如果不相等快指针和满指针同时走一步
           {
               slow=slow->next;
               fast=fast->next;
           }
        }
        return head;
}

 

 

 21. 合并两个有序链表 - 力扣（LeetCode）

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    //含哨兵位的方法
    struct ListNode newnode;
    struct ListNode* head=&newnode;
    head->val=0;
    head->next=NULL;
    struct ListNode* tail=head;
    while(list1!=NULL && list2!=NULL)
    {
      if(list1->val>list2->val)//小的放下来，尾插到哨兵位后面
      {
         tail->next=list2;
         tail=tail->next;
         list2=list2->next;
      }
      else
      {
         tail->next=list1;
         tail=tail->next;
         list1=list1->next;
      }
    }
    if(list1==NULL)//注意情况可能有一边判断完了，另一边还没判断完
    {
       tail->next=list2;
    }
    else if(list2==NULL)
    {
        tail->next=list1;
    }
    return head->next;
}

 

 

struct Node* Buynewnode()//申请节点
{
    struct Node* ret =
        (struct Node*)malloc(sizeof(struct Node));
    if (ret == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    ret->val = 0;
    ret->next = NULL;
    ret->random = NULL;
    return ret;
}
struct Node* copyRandomList(struct Node* head) {
    if(head == NULL) return head;//链表可能为空的情况
    struct Node* cur = head;
    struct Node* tail = head;
    struct Node* Copy = NULL;
    struct Node* nnnhead = head;
    while (cur)//每次在给定的链表后面复制一个相同的节点
    {
        Copy = Buynewnode();//每次复制时申请一个节点
        Copy->val = cur->val;//把此时位置的数值复制给新申请的节点
        Copy->next = cur->next;//先让申请的节点链接到旧链表此时位置的
        //下一个节点
        tail = cur->next;
        cur->next = Copy;//让旧的链表此时的位置的节点的下一个节点
        //链接到这个新节点
        cur = tail;
    }
    cur = head;
    tail = NULL;//追着cur->next看看tail是否在copy
    while (cur)//每次要把随机指针指向复制后的跟旧链表相似的节点
    {
        tail = cur->next;
        if (cur->random != NULL)
        {
            cur->next->random = cur->random->next;//因为当前指针的随机
            //指针的下一个节点就是在前面复制过后的节点
        }
        else
        {
            cur->next->random = cur->random;
        }
        cur = cur->next->next;
    }
    tail = head;//保存前一个节点释放节点,
    cur = head->next;
    struct Node* newhead = head->next;
    while (cur && cur->next )//分离复制后的链表，将复制后的
    //链表重新链接
    {
       
        tail = cur->next;
        cur->next = cur->next->next;
        cur = cur->next;       
    }
    return newhead;
}

 

 

struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB) {
    struct ListNode* c1 = headA;
    struct ListNode* c2 = headB;
    int L1 = 0;
    int L2 = 0;
    while (c1)//判断相差的值
    {
        c1 = c1->next;
        ++L1;
    }
    while (c2)//判断相差的值
    {
        c2 = c2->next;
        ++L2;
    }
    int count = abs(L2 - L1);
    //判断长短
    struct ListNode* Short = headA;//假设法
    struct ListNode* Long = headB;
    if (L2 > L1)//判断长短，重新赋值
    {

    }
    else
    {
        Long = headA;
        Short = headB;
    }
    while (count--)//长的先走
    {
        Long = Long->next;
    }
    while (Short != Long)//等短的和长的走到一起时停止,我们相交
    //之后链表后面的节点数量是一样的，而单链表相交只能指向一个地址
    //不能指向两个地址
    {
        Long = Long->next;
        Short = Short->next;
        if (Short == NULL)
        {
            return NULL;
        }
    }
    return Short;
}

 

带头双向链表

#pragma once
// 带头+双向+链表增删查改实现
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
ListNode* ListCreate()
{
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	if (head == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	head->_next=head->_prev = NULL;
	head->_data = -1;//哨兵位
	return head;
}
// 双向链表销毁
void ListDestory(ListNode* pHead);
void ListDestory(ListNode* pHead)
{
    //这里不用判断是否为空的情况，我们的哨兵位不可能为空
   //因为如果为空，我们在创建哨兵位时就已经退出并报错了
	ListNode* cur = pHead->_next;
	ListNode* tail = pHead->_next;
	while (cur)
	{
		tail = cur;
		cur = cur->_next;
		free(tail);
	}
	pHead->_next = NULL;
	pHead->_prev = NULL;
}
// 双向链表打印
void ListPrint(ListNode* pHead);
void ListPrint(ListNode* pHead)
{
	ListNode* cur = pHead->_next;//不要打印哨兵位的数据
	while (cur)
	{
		printf("%d->", cur->_data);
		cur = cur->_next;
	}
	printf("NULL\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);//尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	ListNode* tail = pHead;//尾插的指针
	ListNode* prev = pHead;//因为要链接前一个，每次遍历时，需要记录上一个节点
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));//申请新节点
//链接到尾节点
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->_next = NULL;
	newnode->_prev = NULL;
	newnode->_data = x;//初始化
	while (tail)
	{
		prev = tail;//为什么每次要记录tail经过的上一个节点
        //因为我们这里是双向链表尾插的时候要链接前一个节点
        //相当于我们是在两个节点中插入，
        //左边是正常节点，右边是空，所以根据我的这个思路就用prev
        //并且因为我们没用追随节点的话，tail走到空，
        //当我们在插入的时候，
		tail = tail->_next;
	}
	tail = newnode;
	prev->_next = tail;
	newnode->_prev = prev;	
}
// 双向链表尾删
void ListPopBack(ListNode* pHead);//尾删
void ListPopBack(ListNode* pHead)
{
	ListNode* tail = pHead;
	//ListNode* prev = pHead;//记录前一个节点,给他的next置为空
	while (tail->_next)
	{
		/*prev = tail;*/
		tail = tail->_next;
	}
	if (tail == pHead)//没有结点的情况
	{
		;
	}
	else
	{
		tail->_prev ->_next = NULL;
		free(tail);
		/*prev->_next = NULL;*/
	}
}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);//头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	ListNode* head = pHead;//哨兵位
	ListNode* cur = pHead->_next;
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));//申请新节点
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->_next = NULL;
	newnode->_prev = NULL;
	newnode->_data = x;//初始化


	newnode->_next = head->_next;//将新节点的next指向哨兵位的下一个节点
	newnode->_prev = head;//将新节点的位置的prev指向哨兵位
	head->_next = newnode;//哨兵位的next指向新节点
	if (newnode->_next == NULL)//空节点
    //因为我们如果是在两个节点中插入的话，当第二个节点为空时，
    //我们就不能让他指向前一个节点
	{
		;
	}
	else
	{
		newnode->_next->_prev = newnode;//第二个节点不为空
	}
}
// 双向链表头删
void ListPopFront(ListNode* pHead);
void ListPopFront(ListNode* pHead)
{
	ListNode* cur = pHead->_next;
	ListNode* tail = cur;
	if (cur)//如果哨兵位后面此时节点为空时，就不要去释放
    //会造成释放空指针
	{
      
	}
	else if (cur->_next == NULL)//如果节点为1的话我们不用重新链接释放过后的节点
	{
		pHead->_next = cur->_next;//让他们指向空就行
		free(cur);
	}
	else//节点不为1和0的情况
	{
		pHead->_next = cur->_next;
		cur->_next->_prev = pHead;
		free(cur);
	}
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	ListNode* cur = pHead->_next;
	while (cur)
	{
		if (cur->_data == x)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->_next = NULL;
	newnode->_prev = NULL;
	newnode->_data = x;

   //链接前后两个节点,因为pos找不到的话（空节点也包括在内）会我们在前面就会判断并退出，所以我们不需要去判断有木有节点
	newnode->_prev = pos->_prev; //将新节点的prev指向pos位置的前一个节点
	newnode->_next = pos;//将新节点的next指向pos，
	pos->_prev->_next = newnode;//将pos指向的前一个节点的next指向新节点
	pos->_prev = newnode;//将pos的prev指向新节点
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);
void ListErase(ListNode* pos)
{
	assert(pos);
	if (pos->_next == NULL)//如果pos的位置是在最后一个的话，我们就不需要去链接
    //新节点，那是为什么呢，我们看第二个条件
	{
		pos->_prev->_next = NULL;
		free(pos);
	}
	else
	{
		pos->_prev->_next = pos->_next;
		pos->_next->_prev = pos->_prev;//如果最后一个节点的nxt指向空，那么
        //pos->_next->_prev就对空指针解引用了
		 free(pos);
	}
}

带头双向循环链表

//带头双向循环链表
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;


// 创建返回链表的头结点.//这个不用改
ListNode* ListCreate();
ListNode* ListCreate()
{
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	if (head == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	head->_next = head->_prev = head;
	head->_data = -1;//哨兵位
	return head;
}
// 双向链表销毁
void ListDestory(ListNode* pHead);
void ListDestory(ListNode* pHead)//不用改
{
	ListNode* cur = pHead->_next;
	ListNode* tail = pHead->_next;
	while (cur && cur != pHead)
	{
		tail = cur;
		cur = cur->_next;
		free(tail);
	}
	pHead->_next = pHead;
	pHead->_prev = pHead;
}
// 双向链表打印
void ListPrint(ListNode* pHead);
void ListPrint(ListNode* pHead)//
{
	ListNode* cur = pHead->_next;
	while (cur && cur != pHead)//我们停止条件是cur指向哨兵位时
	{
		printf("%d->", cur->_data);
		cur = cur->_next;
	}
	printf("NULL\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);//尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
    //因为是带头循环的双向链表，我们在初始化时不需要去判断节点是否为空
	ListNode* tail = pHead;//尾插的指针
	ListNode* prev = pHead;//因为要链接前一个，每次遍历时，需要记录上一个节点
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->_next = NULL;
	newnode->_prev = NULL;
	newnode->_data = x;

    //对比双向链表，我们的链表为空时，哨兵位的next和prev都指向的是自己
    //尾插过程
	newnode->_prev = pHead->_prev;
	newnode->_prev->_next = newnode;
	newnode->_next = pHead;
	pHead->_prev = newnode;
}
// 双向循环链表尾删
void ListPopBack(ListNode* pHead);//尾删
void ListPopBack(ListNode* pHead)
{
    //不用判断链表节点是否为空
	pHead->_prev->_prev->_next = pHead;//因为我们的哨兵位的prev
    //指向的时尾节点
	ListNode* cun = pHead->_prev;
	pHead->_prev = pHead->_prev->_prev;
	if (cun != pHead)
	{
		free(cun);
	}
}
// 双向循环链表头插
void ListPushFront(ListNode* pHead, LTDataType x);//头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	ListNode* head = pHead;//头插的指针
	ListNode* cur = pHead->_next;
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->_next = NULL;
	newnode->_prev = NULL;
	newnode->_data = x;
    
    //头插的过程
	newnode->_next =pHead->_next;
	pHead->_next->_prev = newnode;
	pHead->_next = newnode;
	newnode->_prev = pHead;
}
// 双向链表头删
void ListPopFront(ListNode* pHead);
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	assert(pHead->_next != pHead); 
	ListNode* cur = pHead;

    //记住如果不用cur，那我们得理清他的先后顺序
   //因为顺序错了，可能节点就找不到了
	cur = pHead->_next;
	pHead->_next = pHead->_next->_next;
	pHead->_next->_prev = pHead;
	free(cur);
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	ListNode* cur = pHead->_next;
	while (cur && cur != pHead)
	{
		if (cur->_data == x)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
void ListInsert(ListNode* pos, LTDataType x)//不用改
{
	assert(pos);
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->_next = NULL;
	newnode->_prev = NULL;
	newnode->_data = x;




	newnode->_prev = pos->_prev;
	newnode->_next = pos;
	pos->_prev->_next = newnode;
	pos->_prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* cun = pos;
	pos->_prev->_next = pos->_next;
	pos->_next->_prev = pos->_prev;
	free(cun);
}

乖的小肥羊
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C语言链表题目（附答案）.docx
08-07
大一初学C语言时的期末作业，涉及到链表的建立和功能的实现，涉及指针、函数、动态结构建立等方面的知识，初学者可以参考参考尝试尝试哟！！！
数据结构-双向链表（c语言实现）
southernbrid的博客
04-10 386
/1.创建一个空的双向链表//2.链表指定位置插入数据//3.遍历双向链表//4.指定位置删除 -双向链表// 5.判断双向链表是否为空// 6.求双向链表的长度// 7.查找指定数据出现的位置// 8.修改指定位置的数据// 9.删除双向链表中的指定数据// 10.转置双向链表。
单链表的插入和删除
qq_48795733的博客
07-05 538
单链表的插入与删除 代码
链表插入删除c语言程序
yyd__的博客
07-02 777
链表部分代码（插入，删除等等） #include <stdio.h> #include <stdlib.h>//This is heade function of “malloc” int icount; struct Student { char name[20]; int number; struct Student* next; };/建立一个学生节点 struct ...
C语言链表删除经典笔试题,Problem A: C语言习题 链表建立，插入，删除，输出
weixin_32148861的博客
05-18 124
#include#include#includetypedef struct student{long num;float score;struct student *next;}student;student *creatlink(void){student *head = NULL;student *last , *p ;p =(student *)malloc(sizeof(student)...
c++实现链表增删改查
07-17
c++实现链表增删改查
双向链表的增删改查
03-16
实现双向链表的增删改查功能，dos窗口输入输出，可运行，有注释
线性表和链表的存储和增删改查c++
01-28
线性表和链表的存储和增删改查c++
C语言单双向链表的增删改查以及排序问题完整代码
最新发布
09-04
C语言单双向链表的增删改查以及排序问题完整代码
关于双向链表的增删改查和排序的C++实现
01-20
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表...
c语言链表：编写input（）output（）insert（）delete（）来输入学生成绩
yeranc137的博客
12-30 441
#include<stdio.h> #include<stdlib.h> struct Student { int studid; /*学号*/ char name[10]; /*姓名*/ int score1; int score2; int score3; int total; /*总成绩*/ struct Student *next; /*指向下一个结点的指针*/ }; void inputlist(struct Student *phead
【学习笔记】链表的增删改查以及经典例题总结（C语言实现）
Left_Zzzz的博客
09-28 459
单向链表 基本概念 链表由一个个节点通过指针连接组成，每个节点由数据部分和指针（非数据）部分组成。 数组物理储存方式是连续的，故可以通过下标访问数组，而链表的物理储存方式是不连续的，只能通过指针访问当前节点的下一个节点。 链表中的第一个节点为表头，最后一个节点指向NULL。（好像没有表尾这个说法。。） 链表的基本操作 插入操作 头插法：创建一个节点后，将该节点指针指向链表的头结点，头结点指向新的节点。 尾插法：创建一个节点后，链表中最后一个节点指针指向新的节点，注意新的节点指针要置为NULL。（防
数据结构 之 链表 高频面试题
CSNZのBlog
10-11 3244
一：面试时链表解题的方法论 1、对于笔试，不用太在乎空间复杂度，一切为了时间复杂度 2、对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法 二：链表面试题常用数据结构和技巧 1、使用容器（哈希表、数组等） 2、快慢指针 使用快慢指针的面试题： 1、输入链表头结点，奇数长度返回中点，偶数长度返回上中点 * //输入链表头结点，奇数长度返回中点，偶数长度返回上中点 public static <T> Node<T> midOrUpMidNode(Node<T&g
7-6 链表操作-插入、查找和删除 (100 分)
qq_56165953的博客
06-16 1751
请编写创建链表和输出链表的函数。对于以下数据结点的结构定义， 针对带头结点的链表，请编程完成以下功能。 struct LNode{ int data; //数据域 struct LNode *next; //指针域 }; struct LNode *head; //头指针 输入数据包含若干组命令和数据，一组数据中的第1个字符代表命令， 接下来的是该命令需要的数据。 (1)如果命令是I，功能为创建空链表，对应函数：void List_In.
C语言实现链表的增删查改以及OJ题讲解
m0_69888254的博客
07-29 543
目录 动态申请一个节点 单链表的打印 单链表的尾插 单链表的头插 单链表的尾删 单链表的头删 单链表查找 单链表在pos位置之后插入x 单链表删除pos位置之后的值 单链表的销毁 最后呢，我会挑几道关于链表的OJ题给大家讲解一下 ...
链表的插入与删除
lllllllllllo的博客
08-09 215
链表的插入与删除。
校招选择题汇总【链表(1)】含答案解析
Teacher_HENG
04-10 3398
有问题的下方评论或私信 1.线性表采用链式地址时，其地址(D) A.必须是连续的 B.一定是不连续的 C.部分地址必须是连续的 D.连续与否均可以 解析：线性表两种实现方式，一个用数组，一个用链表。数组中存储空间地址是必需连续的，用链表的话，每创建一个节点其地址是由计算机随机分配的，所以地址不一定连续，但既然是随机的，怎么就不能够随机出连续的可能呢0_0？其实可以这么理解，数组是特...
链表选择题练习
master_1997的博客
09-19 1769
1、已知 pPre 为指向链表中某结点的指针， pNew 是指向新结点的指针，以下哪段伪码算法是将一个新结点插入到链表中 pPre 所指向结点的后面？（C ） A pPre->link = pNew; pNew = null; B pPre->link = pNew->link; pNew->link = null; C pNew->link = p...
【数据结构】 链表 -习题
m0_74195626的博客
04-01 1156
解释：链表中的结点是动态开辟出来的，跟连不连续没关系，可能会动态开辟连续的两块内存空间，但是大概率还是不连续的，因此连续或不连续都可以。在一个单链表head中，若要在指针p所指结点后插入一个q指针所指结点，则执行▁▁▁▁▁。对于D：p->next为a中第二个结构体{7，&a[2]}，p->next->n即为7。对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是▁▁▁▁▁。在一个单链表head中，若要删除指针p所指结点的后继结点，则执行（）。链表要求内存中可用存储单元的地址 ▁▁▁▁▁。
请给出双向链表增删改查的代码
04-07
以下是双向链表增删改查的代码实现： ```python class Node: def __init__(self, data): self.data = data self.prev = None self.next = None class DoublyLinkedList: def __init__(self): self.head = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

乖的小肥羊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值