2024年最新单链表C语言实现附加力扣题_c语言单链单题 力扣(1)，面试杀手锏

最新推荐文章于 2024-07-21 22:06:29 发布
最新推荐文章于 2024-07-21 22:06:29 发布
阅读量830 收藏 26
点赞数 17
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84978603/article/details/138855196
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

//链表销毁
void SLTNodeDestor(SLTNode \*ps) 
{
	assert(ps);
	while (ps) 
	{
		SLTNode \*del = ps;
		ps = ps->next;
		free(ps);
	}
}

打印

请添加图片描述

遍历链表的每个结点，打印这个结点的data

//打印
void SLTprint(SLTNode \*ps) 
{	
	SLTNode \*cur = ps;
	while (cur != NULL) 
	{
		printf("%d->",cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

创建结点

//创建结点
SLTNode \*BuySLTNode(int x) 
{
	SLTNode \*tmp = (SLTNode \*)malloc(sizeof(SLTNode));
	if (!tmp) 
	{
		perror("BuySLTNode::malloc");
		exit(1);
	}
	tmp->data = x;
	tmp->next = NULL;

	return tmp;
}

尾插

请添加图片描述

创建一个新的结点newNode，找到最后一个结点的位置tail，用tail链接newNode，这里要注意的是我们的链表的实现是以不带头为目的的，所以会是一个空表，如果是空表的情况下，需要将ps初始化成为第一个结点，往后尾插就只需要找尾了，这里要传二级指针，为了改变外部的指针

//尾插
void SLTPushBack(SLTNode \*\*ps,int x) 
{
	SLTNode \*newNode = BuySLTNode(x);
	//如果是空表
	if (\*ps == NULL) 
	{
		\*ps = newNode;
	}
	else 
	{
		//尾插找尾
		SLTNode \*tail = \*ps;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newNode;
	}
}

传递一级指针无法改变main函数的plist的指针，因为是在不同的栈帧中开辟的，只是一份值拷贝，互不影响，所以传递二级指针
在这里插入图片描述

头插

请添加图片描述

头插只需要创建一个新的结点newNode，让新的结点链接ps，再让ps去做新的头，由于需要改变外面的指针，还是要传递二级指针，头插即使是面对链表为空还是不会受影响

//头插
void SLTPushFront(SLTNode \*\*ps,int x) 
{
	SLTNode \*newNode = BuySLTNode(x);
	newNode->next = ps;
	//ps去做新的头
	\*ps = newNode;
}

头删

请添加图片描述

头删同样需要改变外面的指针，所以要传二级，移除第一个结点，让第二个结点做新的头

//头删
void SLTPopFront(SLTNode \*\*ps) 
{
	if (\*ps == NULL)
		return;
	SLTNode \*delNode = \*ps;
	\*ps = delNode->next;
	free(delNode);
	delNode = NULL;
}

尾删

请添加图片描述

尾删需要考虑三种情况
1、表为空，不需要删除，直接返回
2、只剩一个结点，删除这个结点，再置空，也需要改变外面指针的指向，必须传二级指针
3、有多个结点，定义前驱指针prev，和目标指针cur，当cur指向最后一个结点的时候释放cur，cur置空，前驱指针prev指向空

//尾删
void SLTPopBack(SLTNode \*\*ps) 
{

	SLTNode \*phead = \*ps;
	//只有一个结点
	if (phead->next == NULL)
	{
		free(phead);
		\*ps = NULL;
		phead = NULL;
	}
	//表为空直接返回
	else if (\*ps == NULL) 
	{
		return ;
	}
	//剩多个结点
	else 
	{	
		//定义前驱指针和目标指针
		SLTNode \*tail= \*ps;
		SLTNode \*prev = NULL;
		
		while (tail->next != NULL)
		{
			prev = tail;
			tail= tail->next;
		}
		//移除最后一个结点，让前一个指针指向空
		free(tail);
		cur = NULL;
		prev->next = NULL;
	}
	
}

查找

查找54
请添加图片描述

找到该结点就返回，没找到就返回空，空表直接返回

//查找
SLTNode\* SLTFind(SLTNode \*ps, int x) 
{
	if (ps == NULL)
		return NULL;
	SLTNode \*cur = ps;
	while (cur != NULL) 
	{
		if (cur->data == x) 
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

指定位置后插入

在pos后面插入一个新的结点，需要备份pos的下一个结点，先让newNode指向第二个结点再让pos指向newNode

//指定位置后插入
void SLTInsertAfter(SLTNode \*pos, int x) 
{
	assert(pos);
	SLTNode \*next = pos->next;
	SLTNode \*newNode = BuySLTNode(x);
	pos->next = newNode;
	newNode->next = next;
}

指定位置前插入

在这里插入图片描述

1、在指定pos的前面插入，如果pos和ps在同一个位置就是头插了
2、如果pos出现在链表的中间某个位置，要想在pos前插入一个新的结点就必须要找到pos前的一个结点prev，让这个结点prev指向新的结点newNode，最后让newNode指向当前结点

//指定位置前插入
void SLTInsertBefor(SLTNode \*\*ps, SLTNode \*pos, int x)
{
	assert(pos);
	SLTNode \*newNode = BuySLTNode(x);
	if (pos == \*ps) 
	{
		newNode->next = \*ps;
		\*ps = newNode;
	}
	else 
	{
		SLTNode \*cur = \*ps;
		SLTNode \*prev = NULL;

		while (cur != pos) 
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = newNode;
		newNode->next = cur;
	}
}

指定位置后删除

在这里插入图片描述

next用来保存pos位置的下一个结点，pos指向next的下一个结点，释放next位置的结点

//移除指定位置之后
void SLTEraseAfter(SLTNode \*pos) 
{
	//表为空不做处理
	if(pos == NULL)
	{
		return ;
	}
	assert(pos);
	SLTNode \*next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;
}

移除指定位置

prev和cur一起一后，当cur与pos相遇了，就将prev链接cur的下一个结点，释放pos位置的结点，将指针置空

在这里插入图片描述

如果plist和pos指向一起，就是头删操作了

在这里插入图片描述

//移除指定位置
void SLTEraseBefor(SLTNode \*\* ps, SLTNode \*pos)
{
	assert(pos);
	SLTNode \*next = pos->next;
	//pos等于ps，头删
	if (\*ps == pos) 
	{
		free(\*ps);
		\*ps = NULL;
		\*ps = next;
	}
	else
	{
		SLTNode \*prev = NULL;
		SLTNode \*cur = \*ps;
		while (cur != pos) 
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = cur->next;
		free(cur);
		cur = NULL;
	}
}

力扣题

移除链表元素:

点我.
在这里插入图片描述
考虑两种场景

  • 1、如果表的第一个结点的值就是val，那么就是头删了，释放第一个结点，需要将head的指向改变，指向下一个结点
  • 2、如果表的所有结点全是val的情况，head的指向就可以一直改变，直到指向NULL，最后返回去的就是NULL

链表移除结点的变形题，把特殊场景处理就能搞定

struct ListNode\* removeElements(struct ListNode\* head, int val){
  
    struct ListNode \*prev = NULL;
    struct ListNode \*cur = head;
    while(cur != NULL)
    {
    	//值为val
        struct ListNode \*del = NULL;
        if(cur->val != val)
        {
            prev = cur;
            cur = cur->next;
        }
        //值不为val
        else
        {
            //如果cur是头的情况
            struct ListNode \*next = cur->next;
            if(prev == NULL)
            {
                free(cur);
                head = next;
                cur = next;
            }
            //cur不是头
            else
            {
                prev->next = next;
                free(cur);
                cur = next;
            }
        }
    }
    return head;
}

第二种写法：带哨兵位的头节点，可以让prev指向哨兵位结点，这样就不需要考虑prev是否会存在空指针的问题了，同样的prev和cur一起一后，找到了值位val的结点，就释放该节点，cur继续指向下一个位置，最后只需要返回哨兵位结点的下一个位置

struct ListNode\* removeElements(struct ListNode\* head, int val){
    struct ListNode\* guard = (struct ListNode\*)malloc(sizeof(struct ListNode));
    guard->next = head;

    struct ListNode \*prev = guard;
    struct ListNode \*cur = head;
    while(cur != NULL)
    {
        if(cur->val != val)
        {
            prev = cur;
            cur = cur->next;
        }
        else
        {
            
            struct ListNode \*next = cur->next;
           
            prev->next = next;
            free(cur);
            cur = next;
        }
    }
    return guard->next;
}

在这里插入图片描述

206. 反转链表:

点我.
实现思路

使用三个指针迭代的方法，prev和cur用来逆置结点的指向，next保证cur能找到下一个结点的位置，直到cur指向空了，循环停止，返回prev指针，整个链表也就逆置了

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

    while(cur)
    {
       //逆置
       cur->next = prev;
       //迭代
       prev = cur;
       cur = next;
       if(next != NULL)
       next = next->next;
    }

    return prev;
}

思路二：必做，链表头插的变型题，将原链表遍历一遍，取原链表的结点头插到新的表中

struct ListNode\* reverseList(struct ListNode\* head){
    struct ListNode \*newhead = NULL;
  
    struct ListNode \*cur = head;
    while(cur)
    {
        struct ListNode \*next = cur->next;
        //头插
        cur->next = newhead;
        newhead = cur;
        //迭代
        cur = next;
    }
    return newhead;
}

876. 链表的中间结点:

点我.
在这里插入图片描述

快慢指针解法，快指针走两步慢指针走一步，当快指针走到链表NULL位置的时候，或者快指针走到最后一个结点的位置，循环终止，返回慢指针

struct ListNode\* middleNode(struct ListNode\* head){
    if(head == NULL)
    {
        return NULL;
    }
    struct ListNode\* fast = head;
    struct ListNode\* slow = head;
    while(fast && fast->next)
    {
        slow = slow->next;
       
        fast = fast->next->next;
       
    }

    return slow;
}

链表中倒数第k个结点:

点我.
在这里插入图片描述

快指针先走k步，快指针走完k步后，快指针和慢指针一起走，当快指针走完了，slow就是倒数第k个结点，就返回slow的位置

极端情况：如果fast先走k步，k大于链表的长度，链表可能存在空表，是空表就返回NULL

struct ListNode\* FindKthToTail(struct ListNode\* pListHead, int k ) {
    // write code here
    struct ListNode\* fast = pListHead;
    struct ListNode\* slow = pListHead;
    
    while(k--)
    {
        //k大于链表长度，fast已经走到NULL了，
        if(fast == NULL)
            return NULL;
        fast = fast->next;
    }
    
    while(fast)
    {
       fast = fast->next;
       slow = slow->next;
    }
    return slow;
}

21. 合并两个有序链表

链接: 点我.
在这里插入图片描述

思路：合并两个链表只需要将原链表中最小的值尾插到新链表中去

struct ListNode\* mergeTwoLists(struct ListNode\* l1, struct ListNode\* l2){
    if(l1 == NULL)
    return l2;
    if(l2 == NULL)
    return l1;
    if(l1 == NULL && l2 == NULL)
    return NULL;
    
    struct ListNode\* newList = NULL;
    struct ListNode \*tail = newList;
	//取下最小值做新链表的头
    if(l1->val < l2->val)
    {
        newList = tail = l1;
        l1 = l1->next;
    }
    else
    {
        newList = tail = l2;
        l2 = l2->next;
    }
	//取两个链表中最小值尾插到新的链表中去
    while(l1 && l2)
    {
       if(l1->val < l2->val)
       {
           tail->next = l1;
           l1 = l1->next;
       }
       else
       {
           tail->next = l2;
           l2 = l2->next;
       }
       tail = tail->next;
    }

	//如果有一个链表还没遍历完就继续尾插到新链表去
    if(l1)
    {
        tail->next = l1;
    }
    if(l2)
    {
        tail->next = l2;
    }

    return newList;
}

带哨兵位的头节点不需要考虑新链表头尾都是是NULL的这种情况

struct ListNode\* mergeTwoLists(struct ListNode\* l1, struct ListNode\* l2){
	//创建哨兵头节点
    struct ListNode\* head = (struct ListNode\*)malloc(sizeof(struct ListNode));
    struct ListNode\* tail = head;
    tail->next = NULL;

    while(l1 && l2)
    {
        if(l1->val < l2->val)
        {
            tail->next = l1;
            l1 = l1->next;
        }
        else
        {
            tail->next = l2;
            l2 = l2->next;
        }
        tail = tail->next;
    }

    //还剩的
    if(l1){
        tail->next = l1;
    }
    if(l2){
        tail->next = l2;
    }
	
	//释放动态开辟的结点，返回新的头
    struct ListNode\* node = head;
    head = head->next;
    free(node);
    return head;
}

OR36 链表的回文结构

链接: 点我 .
在这里插入图片描述

解题思路：先找出中间结点（快慢指针法），将中间结点起始位置往后整体逆置，返回逆置后的头指针，得到后部分逆置的链表，再跟原链比较

class PalindromeList {
public:
    struct ListNode\* middleNode(struct ListNode\* head){
    if(head == NULL)
    {
        return NULL;
    }
    struct ListNode\* fast = head;
    struct ListNode\* slow = head;
    while(fast && fast->next)
    {
        slow = slow->next;
       
        fast = fast->next->next;
       
    }

    return slow;
}
    struct ListNode\* reverseList(struct ListNode\* head){
    if(head == NULL)
    {
        return NULL;
    }
    
    struct ListNode\* cur = head;
    struct ListNode\* prev = NULL;
    struct ListNode\* next = cur->next;

    while(cur)
    {
       //逆置
       cur->next = prev;
       //迭代
       prev = cur;
       cur = next;
       if(next != NULL)
       next = next->next;
    }

    return prev;
}
    bool chkPalindrome(ListNode\* A) {
        // write code here
        //找到中间结点整体逆置，最后比较
        struct ListNode\* mid = middleNode(A);
        struct ListNode\* rhead = reverseList(mid);
        
        //比较
        while(A && rhead)
        {
            if(A->val != rhead->val)
            {
                return false;
            }
            else
            {
                A = A->next;
                rhead = rhead->next;
            }
        }
        return true;
    }
};

在这里插入图片描述
160. 相交链表
链接: 点我.

链表的相交并不是直线的相交，而是两个链表中存在一个公共结点，这样的链表我们可以称它是相交链表，比较结点的地址，如果相同那么就是相交的，否则不是，让长距离的先走差距步，最后再同时走，如果中间相交就返回该结点，否则返回NULL

struct ListNode \*getIntersectionNode(struct ListNode \*headA, struct ListNode \*headB) {
    //记录链表的长度
    int lenA = 0,lenB = 0;
    struct ListNode \*curA = headA;


![img](https://img-blog.csdnimg.cn/img_convert/c8d15002a50694c702d8c16375808cd6.png)
![img](https://img-blog.csdnimg.cn/img_convert/67563b8fc86217494accf3edb57fe52d.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

在这里插入图片描述
160. 相交链表
链接: 点我.

链表的相交并不是直线的相交，而是两个链表中存在一个公共结点，这样的链表我们可以称它是相交链表，比较结点的地址，如果相同那么就是相交的，否则不是，让长距离的先走差距步，最后再同时走，如果中间相交就返回该结点，否则返回NULL

struct ListNode \*getIntersectionNode(struct ListNode \*headA, struct ListNode \*headB) {
    //记录链表的长度
    int lenA = 0,lenB = 0;
    struct ListNode \*curA = headA;


[外链图片转存中...(img-9LxILmYW-1715669456468)]
[外链图片转存中...(img-8w02yCSX-1715669456469)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**
2401_84978603
关注
  • 17
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最新单链表C语言实现附加力扣题_c语言单链单题 力扣，2024年最新真香警告
2401_84978510的博客
05-17 237
今天我们的主题是实现单向不带头不循环的单链表。
2024年C C++最新单链表C语言实现附加力扣题_c 力扣 遍历 单链表(1)，2024年最新C C++面试项目源码
2401_84976619的博客
05-13 981
/如果不相遇那么链表的最后一个结点一定不同。//找到中间结点整体逆置，最后比较。//定义长的链表，定义短的链表。//pos等于ps，头删。//长链表先走gap步。//移除指定位置之后。
2024年C C++最新单链表C语言实现附加力扣题_c语言单链单题 力扣(2)，一份非常适合收藏的C C++进阶面试题
2401_84976619的博客
05-13 1027
要想复制一份链表比较得保证新链表的结点关系和原链表保持一致，并且新链表的每个结点的值以及结点中两个指针的指向都必须与原链表结点一样，将拷贝链表的结构构建出来后，同步拷贝链表和原链表两个指针的指向，最后将拷贝链表拆解下来，同时还原原链表结点的链接的关系，最后返回拷贝链表的头。链表的相交并不是直线的相交，而是两个链表中存在一个公共结点，这样的链表我们可以称它是相交链表，比较结点的地址，如果相同那么就是相交的，否则不是，让长距离的先走差距步，最后再同时走，如果中间相交就返回该结点，否则返回NULL。
2024年C C++最全单链表C语言实现附加力扣题_c 力扣 遍历 单链表，2024年最新掌握这个提升路径,
2401_84975411的博客
05-13 792
(img-9vqrjJgo-1715537810104)](img-Lo8wDbrG-1715537810104)]//相遇后,meet从相遇点开始走，head从起点开始走，//如果不相遇那么链表的最后一个结点一定不同。//创建哨兵位头节点，新链表的尾结点。//创建哨兵位头节点，新链表的尾结点。//找到中间结点整体逆置，最后比较。//定义长的链表，定义短的链表。//同步拷贝结点的随机指针。//同步拷贝结点的随机指针。//长链表先走gap步。//建立拷贝结点的关系。//移除指定位置之后。
2024年最新栈和队列C语言实现附加力扣题_力扣栈怎么传参c语言，2024年最新阿里+头条+抖音+百度+蚂蚁+京东面经
2401_84973321的博客
05-14 546
(img-xD32c17u-1715672131571)](img-NFdlO3EL-1715672131571)]//非空队列往空队列里面倒数据，只剩一个数据的时候就将他释放并返回。//队列的尾部元素，等于栈顶的元素，取非空队列的尾部元素。//往不为空的队列里面倒数据,保证一个队列是空的。//两个队列都释放，最后释放obj。//两个队列都不为空栈就不为空。//求队列的元素个数。//求队列的元素个数。//求队列的元素个数。//求队列的元素个数。//获取栈顶元素个数。//获取栈顶元素个数。
力扣算法题用c语言实现,刷题-力扣-25
weixin_30737899的博客
05-24 1156
刷题-力扣-2525. K 个一组翻转链表题目链接来源：力扣(LeetCode)链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。题目描述给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不...
C C++最全栈和队列C语言实现附加力扣题_力扣栈怎么传参c语言(1)，2024年最新又是一年金九银十
2401_84978565的博客
05-15 781
assert(ST);if(!ST->top–;//获取栈顶元素assert(ST);//判断栈是否空assert(ST);//获取栈顶元素个数assert(ST);//入栈assert(ST);exit(-1);//弹栈assert(ST);if(!ST->top–;}QueueNode;}Queue;//初始化//销毁。
（C语言版）力扣（LeetCode）面试题 17.04. 消失的数字5种解法
立志做一个高产且细节博主
04-12 1832
（C语言版）力扣（LeetCode）面试题 17.04. 消失的数字5种解法
力扣新手题单6题，C语言常规解答
weixin_44077290的博客
11-06 885
力扣新手题单6题，C语言常规解答
[C/C++入门][ifelse]18、Switch星期课表
qq_14840819的专栏
07-17 335
必须是一个常量或常量表达式，通常是整数值。分支被选中时要执行的语句序列。
IO多路复用-poll的使用详解【C语言】
qq_42037383的博客
07-21 575
poll是一种用于监控多个文件描述符状态的系统调用，它可以等待多个文件描述符上的事件发生。它与select和epoll类似，但在某些场景下使用更为方便。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 224
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 564
学懂C语言系列,C语言基本语法
C++笔试强训7
最新发布
m0_74189279的博客
07-21 521
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作
zhyjhacker的博客
07-21 721
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 126
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 1476
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
【C++】获取环境变量
Badme
07-18 7705
【C++】获取环境变量
力扣面试必备：150道算法题解析与实战
"这份资源主要包含了力扣(LeetCode)面试中的150道经典题目，旨在帮助面试者准备数据结构和算法相关的面试。题目类型多样，涵盖了数组、链表、树、图、动态规划和贪心算法等多个领域，旨在全面提升程序员解决实际问题...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值