单链表的相关面试题

最新推荐文章于 2022-11-04 18:01:21 发布
最新推荐文章于 2022-11-04 18:01:21 发布
阅读量392 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 单链表 约瑟夫环 判断两个单链表是否相交 逆序正序打印单链表 单链表的插入删除头插尾插冒泡排序等
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Silence723/article/details/51799484
版权
一、比较顺序表与链表的优缺点：
单链表：它是一种链式存储的线性表，用一组地址任意的存储单元存放线性的的数据元素，称存储单元为一个节点。
顺序表：采用顺序存储结构的线性表通常称为顺序表。
线性表的顺序存储结构：指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间的逻辑上的相邻关系。
线性表优点：
   因为逻辑上相邻的元素其存储的物理位置也是相邻的，所以无需为表示结点间的逻辑关系而增加额外的存储空间，并且具有可以方便的随机存取表中任一元素。
线性表缺点：
1、插入或删除运算不方便，除表尾的位置外，在表的其他位置上进行插入或者删除操作都必须移动大量的结点，其效率非常低。
2、由于顺序表要求占用连续的存储空间，存储分配只能预先进行静态分配。因此，当表的长度变化较大时，难以确定合适的存储规模。若按照可能达到的最大长度预先分配表空间，则可能造成一部分空间长期闲置而得不到充分利用；若事先对表的长度估计不足，则插入操作可能使表长超过预先分配的空间而造成溢出。
1、顺序表支持随机访问，单链表不支持随机访问。
2、顺序表插入/删除数据效率很低，时间复杂度为O(N)（除尾插尾删），单链表插入/删除效率更高，时间复杂度为O(1)。
3、顺序表的CPU高速缓存效率更高，单链表CPU高速缓存效率低。

//单链表头插
void PushFront(pSListNode * pHead , DataType data )
{
          assert( pHead );
           if ( pHead == * pHead )
          {
                   *phead = ByeNode( data );
          }
           else
          {
                   pSListNode pNode = ByeNode( data );
                   pNode->pNext = * pHead ;
                   * pHead = pNode;
          }

}

//单链表头删
void PopFront(pSListNode * pHead )
{
          assert( pHead != NULL);
           if (* pHead == NULL)
          {
                    return ;
          }
           else
          {
                   pSListNode pNode = * pHead ;
                   * pHead = pNode->pNext;
                   free(pNode);
          }
}

//单链表查找一个结点
pSListNode Find(pSListNode pHead , pSListNode Pos , DataType data )
{
          pSListNode pNode = pHead ;
           while (pNode)
          {
                    if (pNode->data == data )
                   {
                              return pNode;
                   }
                   pNode = pNode->pNext;
          }
           return NULL;
}

//删除单链表的某个结点
void Erase(pSListNode * pHead , pSListNode Pos )
{
          pSListNode pPrePos = * pHead ;
          assert(NULL != pHead );
          assert(NULL != Pos );
           if ( Pos == * pHead )
          {
                   * pHead = Pos ->pNext;
                   free( Pos );
                    return ;
          }
           while ((pPrePos != NULL) && (pPrePos->pNext != Pos ))
          {
                   pPrePos = pPrePos->pNext;
          }
           if (pPrePos->pNext == Pos )
          {
                   pPrePos->pNext = Pos ->pNext;
                   free( Pos );
          }
          
}



//单链表插入
void Insert(pSListNode * pHead , pSListNode Pos , DataType data )
{
          pSListNode pNewNode = NULL;
          assert(NULL != pHead );
          assert( Pos != NULL);
           if (* pHead == NULL)
                    return ;
          pNewNode = ByeNode( data );
           if (NULL != pNewNode)
          {
                   pNewNode->pNext = Pos ->pNext;
                    Pos ->pNext = pNewNode;
          }

}

//正向打印单链表
void PrintList(pSListNode pHead )
{
          pSListNode pCurNode = pHead ;
           while (pCurNode)
          {
                   printf( "%d->" , pCurNode->data);
                   pCurNode = pCurNode->pNext;
          }
          printf( "NULL\n" );
}


//逆向打印单链表
void PrintListTailToHead(pSListNode pHead )
{
           if (NULL != pHead )
          {
                   PrintListTailToHead( pHead ->pNext);
                   printf( "%d->" , pHead ->data);
          }

}



//销毁单链表
void DestroyList(pSListNode * pHead )
{
          pSListNode pNode = NULL;
          pSListNode pPreNode = NULL;
          assert( pHead != NULL);
          pNode = * pHead ;
           while (pNode)
          {
                   pPreNode = pNode;
                   pNode = pNode->pNext;
          }
          free(pPreNode);
          * pHead = NULL;
}



//删除一个无头单链表的非尾结点

void DelNotTailNode(pSListNode Pos )
{
          pSListNode pDelNode = NULL;
          assert( Pos != NULL);
          assert( Pos ->pNext != NULL);
          pDelNode = Pos ->pNext;
           Pos ->data = pDelNode->data;
           Pos ->pNext = pDelNode->pNext;
          free(pDelNode);
}



//在无头单链表的一个非头结点前插入一个结点

void InsertNotHead(pSListNode Pos , DataType data )
{
          pSListNode pNewNode = NULL;
          assert( Pos != NULL);
          pNewNode = ByeNode( Pos ->data); //新结点保存的是旧结点的值
           if (pNewNode != NULL)
          {
                   pNewNode->pNext = Pos ->pNext;
                    Pos ->pNext = pNewNode;
                    Pos ->data = data ;
          }

}



//查找单链表的中间结点，要求只能遍历一次链表

pSListNode FindMidNode(pSListNode pHead )
{
          pSListNode pSlow = pHead ;
          pSListNode pFast = pHead ;
           while ((pFast != NULL) && (pFast->pNext != NULL))
          {
                   pSlow = pSlow->pNext;
                   pFast = pFast->pNext->pNext;
          }
           return pSlow;
}



//单链表实现约瑟夫环
pSListNode JosephCircle(PsListNode pHead , int M )
{
          pSListNode pNode = pHead ;
          pSListNode pDelNode = pHead ;
           int k = M ;
           if (( pHead == NULL) || ( M <= 0))
          {
                    return NULL;
          }
           while (pNode->pNext != pNode)
          {
                   k = M ;
                    while (--k)
                   {
                             pNode = pNode->pNext;
                   }
                   pDelNode = pNode->pNext;
                   pNode->data = pDelNode->data;
                   pNode->pNext = pDelNode->data;
                   free(pDelNode);
          }
           return NULL;
}


//逆置与反转单链表
//头插法
void ReverseList(pSListNode * pHead )
{
          pSListNode pNode = NULL;
          pSListNode pPreNode = NULL;
          pSListNode pNewNode = NULL;
          assert( pHead != NULL);
           if ((* pHead == NULL)||(* pHead )->pNext==NULL)
          {
                    return ;
          }
          pNode = * pHead ;
           while (pNode)
          {
                   pPreNode = pNode;
                   pNode = pNode->pNext;
                   pPreNode->pNext = pNewNode;
                   pNewHead = pPreNode;
          }
          * pHead = pNewNode;
}



//单链表冒泡排序法

void BubbleSortList(pSListNode pHead )
{
          pSListNode pTailNode = NULL;
          pSListNode pNode = NULL;
          pSListNode pPreNode = NULL;
           if ( pHead == NULL)
          {
                    return ;
          }
           //外循环：控制循环次数
           //内循环：实现冒泡
           while ( pHead != pTailNode)
          {
                   pNode = pHead ;
                    while (pNode->pNext != pTailNode)
                   {
                             pPreNode = pNode;
                             pNode = pNode->pNext;
                              if (pPreNode->data > pNode->data)
                             {
                                      DataType tmp = preNode->data;
                                      pPreNode->data = pNode->data;
                                      pNode->data = tmp;
                             }
                   }
                   pTailNode = pNode;
          }
}


//合并两个有序单链表，且新链表也为有序单链表-------尾插法
pSListNode MergeList(pSListNode pList1 , pSListNode pList2 )
{
          pSListNode pNewHead = NULL;
          pSListNode pL1Node = pList1 ;
          pSListNode pL2Node = pList2 ;
          pSListNode pNode = NULL;
          pSListNode pTailNode = NULL;
           //判断两个单链表是否为空
           if (pL1Node == NULL)
          {
                    return pL2Node;
          }
           if (pL2Node == NULL)
          {
                    return pL1Node;
          }
           //两个单链表都不为空时比较两个单链表中的结点数据的大小，找出较小值赋给新头结点,然后在新头结点后面进行尾插
           if (pL1Node->data > pL2Node->data)
          {
                   pNode = pL2Node;
                   pL2Node = pL2Node->pNext;
          }
           else
          {
                   pNode = pL1Node;
                   pL1Node = pL1Node->pNext;
          }
          pNewHead = pNode;
          pTailNode = pNode;
           //判断两个链表中是否有一个链表结束
           while (pL1Node && pL2Node)
          {
                    if (pL1Node->data > pL2Node->data)
                   {
                             pNode = pL2Node;
                             pL2Node = pL2Node->pNext;
                   }
                    else
                   {
                             pNode = pL1Node;
                             pL1Node = pL1Node->pNext;
                   }
                   pTailNode->pNext = pNode;
                   pTailNode = pTailNode->pNext;
          }
           //链表L1结束，则将L2直接链在尾结点的下一个位置上。否则反之。
           if (pL1Node == NULL)
          {
                   pTailNode->pNext = pL2Node;
          }
           else
          {
                   pTailNode->pNext = pL1Node;
          }
           return pNewHead;
}


//查找单链表中的倒数第k个结点，要求只能遍历一次链表

pSListNode FindLastkNode(pSListNode pHead , int k )
{
          pSListNode pFast = pHead ;   //使用快慢指针，快指针先走k-1步之后，慢指针（走一步）再与快指针同时走，最后返回慢指针即是倒数第k个结点。
          pSListNode pSlow = pHead ;
           if (( pHead == NULL) || ( k <= 0))
          {
                    return NULL;
          }
           //先让快指针走k-1步
           while ((-- k ) && pFast)  //可改为while(k--),则下面的判断k则不需要了，且线面的while(pFast->pNext)也要对应改为while(pFast)。
          {
                   pFast = pFast->pNext;
          }
          
           //判断k是否大于结点数目
           if ( k )
          {
                    return NULL;
          }
           while (pFast->pNext)
          {
                   pSlow = pSlow->pNext;
                   pFast = pFast->pNext->pNext;
          }
           return pSlow;
}



//判断一个链表是否带环？若带环，求环的长度。


//可以使用快慢指针，快指针走两步，慢指针走一步，若相遇，则带环。
int HasCycle(pSListNode pHead )
{
          pSListNode pFast = pHead ;
          pSListNode pSlow = pHead ;
           if ( pHead == NULL)
          {
                    return -1;
          }
           while (pFast && pFast->pNext)
          {
                   pFast = pFast->pNext->pNext;
                   pSlow = pSlow->pNext;
                    if (pSlow == pFast)
                   {
                              return 1; //有环
                   }
                    else
                   {
                              return -1;
                   }
          }
}

//求环的长度

int GetCycleLen(pSListNode pMeetNode )
{
           int len = 1; //千万注意
          pSListNode pNode = pMeetNode ;
           if ( pMeetNode == NULL)
          {
                    return 0;
          }
           while (pNode->pNext != pMeetNode )
          {
                   len++;
          }
           return len;
}
//求环的入口点
//定义两个指针，一个指针从pMeetNode结点开始走，一个指针从头结点开始走，两个指针相遇的地方就是环的入口点。

pSListNode FindEnterNode(pSListNode pHead , pSListNode pMeetNode )
{
          pSListNode pNode1 = pHead ;
          pSListNode pNodeM = pMeetNode ;
           if (( pHead == NULL) || ( pMeetNode == NULL))    //pMeetNode为空，即此单链表无环。
          {
                    return NULL;
          }
           while (pNode1 != pNodeM)    //两指针不相等时指针继续往下走，直到两指针相等跳出循环。
          {
                   pNode1 = pNode1->pNext;
                   pNodeM = pNodeM->pNext;
          }
           return pNode1;
}



//判断两个指针是否相交？
//方法一：相交的情况有Y型和V型等情况，若两个链表相交，则必定有相等的结点，或是从某个结点之后的所有结点都相等，或是最后一个结点相等，所以我们只需判断两个链表的最后一个结点是否相等即可。
//方法二：我们可以先求出两个链表的长度，然后定义两个指针，长度较长的链表指针为p1，长度为L1，另一个链表指针为p2，长度为L2，先让p1走上L1-L2步，再让p1与p2同时往下走，若p1=p2,则两个链表相交。

//方法一实现：

int IsListCrose(pSListNode pL1 , pSListNode pL2 )
{
          pSListNode pL1Node = pL1 ;
          pSListNode pL2Node = pL2 ;
           if (( pL1 == NULL) || ( pL2 == NULL))
          {
                    return 0;
          }
           while (pL1Node->pNext != NULL)
          {
                   pL1Node = pL1Node->pNext;
          }
           while (pL2Node->pNext != NULL)
          {
                   pL2Node = pL2Node->pNext;
          }
           if (pL1Node == pL2Node)
          {
                    return 1;
          }
           return 0;
}


//方法二实现：

int LengthList(pSListNode pHead )
{
          pSListNode pNode = NULL;
           int Len = 0;
          pNode = pHead ->pNext;
           while (pNode != NULL)
          {
                   Len++;
                   pNode = pNode->pNext;
          }
           return Len;
}

int IsListCrose(pSListNode P1 , pSListNode P2 )
{
           int L1 = 0;
           int L2 = 0;
           int K = 0;
          pSListNode pL1Node = P1 ;
          pSListNode pL2Node = P2 ;
           if (( P1 == NULL) || ( P2 == NULL))
          {
                    return 0;
          }
          L1=LengthList( P1 );
          L2=LengthList( P2 );
          K = L1 - L2;
           if (K>0)
          {
                    while (K--)
                   {
                             pL1Node = pL1Node->pNext;
                   }
                    while (pL1Node)
                   {
                             pL1Node = pL1Node->pNext;
                             pL2Node = pL2Node->pNext;
                   }
                    if (pL1Node == pL2Node)
                   {
                              return 1;
                   }
          }
           else
          {
                    while (K++)
                   {
                             pL2Node = pL2Node->pNext;
                   }
                    while (pL2Node)
                   {
                             pL1Node = pL1Node->pNext;
                             pL2Node = pL2Node->pNext;
                   }
                    if (pL1Node == pL2Node)
                   {
                              return 1;
                   }
          }
           return 0;
}



//若两个链表可能相交，求他们的交点。
//相交有三种情况：
//（1）两个链表都不带环。
//（2）两个链表都带环。分别是环外相交与环内相交。
//（3）只有一个带环。此种情况不需要管。
//相交时两个链表公共一个环。


//设M1与M2分别是两个链表与环的交点，若两个链表相交，则M1与M2都在环内。
int IsListCroseWithCycle(pSListNode pL1 , pSListNode pL2 )
{
          pSListNode pL1MeetNode = NULL;
          pSListNode pL2MeetNode = NULL;
          pSListNode pL1Node = pL1 ;
          pSListNode pL2Node = pL2 ;
           if (( pL1 == NULL) || ( pL2 == NULL))
          {
                    return 0;
          }
           //判断两个链表是否带环
          pL1MeetNode = HasCycle( pL1 );
          pL2MeetNode = HasCycle( pL2 );
           //两个链表都不带环。
           if ((pL1MeetNode == NULL) && (pL2MeetNode == NULL))
          {
                    while (pL1Node->pNext != NULL)
                   {
                             pL1Node = pL1Node->pNext;
                   }
                    while (pL2Node ->pNext != NULL)
                   {
                             pL2Node = pL2Node->pNext;
                   }
                    if (pL1Node == pL2Node)
                   {
                              return 1;
                   }
                    return 0;
          }
           //两个链表都带环。若两个链表的pL1MeetNode与pL2MeetNode都在环内，则相交。
           if ((pL1MeetNode != NULL) && (pL2MeetNode != NULL))
          {
                    //先让pL1MeetNode走上一圈，如果在某个地方pL1MeetNode等于pL2MeetNode，则两个链表相交。
                   pSListNode pNode = pL1MeetNode;
                    while (pNode->pNext != pL1MeetNode)   //确保pL1MeetNode走完一圈。
                   {
                              if (pL2MeetNode == pNode)         //判断pL1MeetNode是否等于pL2MeetNode
                             {
                                       return 1;
                             }
                             pNode = pNode->pNext;
                   }
                    return 0;
          }
           return 0;
}
Silence723
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【经典面试题】单链表的常见面试题
01-20
文章目录求单链表中有效节点的个数查找单链表中倒数第k个节点【新浪面试题】单链表的反转【腾讯面试题】从尾到头打印单链表【百度面试题，要求方式1：反向遍历。方式2：Stack栈】 单链表的常见面试题有如下： 1.求...
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6351
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
10道经典链表面试题
xaiobit_hl的博客
05-18 3492
目录 1.删除链表中等于给定值val的所有节点 2.反转一个单链表 3.给定一个带有头结点head的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所 有节点组成的 6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的 结点之前 7. 链表的回文结构 8. 输入两个链表，找出它们.........
链表常见面试题( 建议收藏！！)
一朵花花
08-31 3545
链表面试题????1.删除链表中等于给定值 val 的所有节点2.二级目录3.三级目录 1.删除链表中等于给定值 val 的所有节点 题目： 题目链接： https://leetcode-cn.com/problems/remove-linked-list-elements/. 思考： 用tmp记录当前节点，若tmp 的下一个节点不为空且下一个节点的节点值等于给定的 val，则需要删除tmp的下一个节点 2.二级目录 3.三级目录 ...
链表常见面试题
艾小方的博客
10-25 536
链表面试题 文章目录链表面试题前言一、 删除链表中等于给定值 val 的所有节点。二、反转一个单链表。三、给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。四、输入一个链表，输出该链表中倒数第k个结点。五、 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。六、 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。七、 链表的回文结构。八、 两个链表相交问题九、 链
链表之十大经典面试题
weixin_64702703的博客
04-06 1164
快速学习链表面试题
单链表的基本操作面试题
07-11
单链表的基本操作：建立，查找，插入，删除等。 检查单链表是不是有环。 寻找单链表的中间元素。 单链表反转。
算法大全面试题数据结构单链表的13道面试题含代码
12-17
算法大全面试题数据结构单链表的13道面试题含代码 1.单链表反转 2.找出单链表的倒数第四个元素 3.找出单链表的中间元素 4...
超实用的面试题整理
05-18
HashMap是基于哈希表实现的，每一个元素是一个key-value对，其内部通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。 HashMap是非线程安全的，只是用于单线程环境下，多线程环境下可以采用...
Java数据结构与算法-单链表 新浪，腾讯面试题详解
12-22
单链表常见的几个面试题 新浪，腾讯内部面试题目 题目分析 代码实现 测试用例 一，面试题目 统计链表中有效节点的个数（不含头结点）【新浪】 获取链表中倒数第K个元素【新浪】 单向链表的逆转【腾讯】 二，题目分析...
常见的链表面试题大汇总
09-05
常见的链表面试题大汇总： 1，创建一个链表结点 2，遍历链表中的所有结点 3，倒序打印链表 4，往链表末尾添加结点 5，往链表前端添加结点, 6，获取链表的节点数目 7，销毁链表 8，求链表中倒数第K个节点 9，反转链表 10，查找链表中间节点 11，判断链表是否有环 12，判断链表是否有环，并返回环上的节点数目
链表常见面试题分析
GG_Bruse的博客
11-04 6699
接下来我们会从易到难，逐步讲解有关链表的常见面试，部分题目来自Leetcode和牛客
链表经典面试题（含图解）
ZJRUIII的博客
11-08 2061
文章目录一、删除链表中等于给定值 **val** 的所有节点二、反转单链表三、找链表的中间结点四、找链表中的第k个结点五、合并两个有序链表六、分隔链表七、删除排序链表中的重复元素八、判断一个链表是否是回文链表九、两个链表的第一个公共节点十、判断一个链表是否有环十一、判断一个链表是否有环，并返回第一个结点 一、删除链表中等于给定值 val 的所有节点 对应leetcode题 因为要删除某一个结点，就要遍历到该结点之前的位置。为了记录需要删除的结点的前一位置，我们需要另外创建一个指针pre来记录。先不对头结点
顺序存储结构的优点和缺点
热门推荐
dwt_981208的博客
07-22 1万+
顺序存储结构的优点和缺点 优点： 1.无需为表示结点间的逻辑关系而增加额外的存储空间； 2.可方便地随机存取表中的任一元素。 缺点： 1.插入或删除运算不方便，除表尾的位置外，在表的其它位置上进行插入或删除操作都必须移动大量的结点，其效率较低； 2.由于顺序表要求占用连续的存储空间，存储分配只能预先进行静态分配。因此当表长变化较大时，难以确定合适的存储规模。 ...
链表经典面试题
开心的博客
09-07 369
删除链表中等于给定值 val 的所有节点 public ListNode removeElements(ListNode head, int val) { if(head == null){ return null; }else{ ListNode cur = head; ListNode prev = head; while(cur!=null){ .
单链表常见面试题
weixin_33739627的博客
04-02 89
一、比较顺序表与链表的优缺点：单链表：它是一种链式存储的线性表，用一组地址任意的存储单元存放线性的的数据元素，称存储单元为一个节点。顺序表：采用顺序存储结构的线性表通常称为顺序表。线性表的顺序存储结构：指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间的逻辑...
搞懂单链表常见面试题
weixin_34161032的博客
03-09 613
搞懂单链表常见面试题 Hello 继上次的 搞懂基本排序算法，这个一星期，我总结了，我所学习和思考的单链表基础知识和常见面试题，这些题有的来自 《剑指 offer》 ,有的来自《程序员代码面试指南》，有的来自 leetCode，不是很全面，但都具有一定代表性，相信大家看完以后一定跟我一样，对面试的时候算法题又多了一份自信。不过文章仍然是又臭又长，希望大家备好咖啡，火腿肠，方便面之类的，慢慢看，如...
Java数据结构与算法-链表(单链表、双向链表、环形链表、约瑟夫问题)[day02]
SwaeLeeUknow的博客
09-04 464
day02-链表 单链表介绍和内存布局 链表是有序的列表，但是内存中是实际存储结构如下： 小结: 1.链表是以节点的方式来存储,是链式存储(即各个节点之间并不一定是连续存储的，而是相互指向的); 2.每个节点包含 data 域:存放数据的域， next 域：指向下一个节点; 3.如图：发现链表的各个节点不一定是连续存储; 4.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定. 单链表(带头结点) 逻辑结构示意图如下: 单链表创建和遍历的分析实现 例子 使用带head头的单向
Linux操作系统相关习题集
最新发布
04-25
Linux操作系统相关习题集，包含常用名、Linux系统基础知识等
react相关面试题
08-29
总结起来，React相关的面试题主要涉及React的基础知识、组件使用、状态管理、路由导航以及与前端开发相关的技术。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值