2024年C C++最全单链表C语言实现附加力扣题_c 力扣 遍历 单链表，2024年最新掌握这个提升路径,

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

img
img

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

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

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

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  
 ![请添加图片描述](https://img-blog.csdnimg.cn/b6b3ef6d4b624443828a2f4b2fafd0b3.gif)



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

//查找
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;
}


### 指定位置前插入


![在这里插入图片描述](https://img-blog.csdnimg.cn/4a6bbe415f5541caa166e0a408680954.gif#pic_center)



> 
> 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;
}

}


### 指定位置后删除


![在这里插入图片描述](https://img-blog.csdnimg.cn/bf026637f5f0477ba687d95b8cf2036a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)



> 
> 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位置的结点，将指针置空
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/b2b3de24db174b2b82ac23e6cd419c35.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)



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


![在这里插入图片描述](https://img-blog.csdnimg.cn/7f4f8c88e0624eb9b047d55994f3ccab.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)

//移除指定位置
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;
}
}


## 力扣题


### 移除链表元素:


[点我](https://bbs.csdn.net/topics/618668825).  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/196e91a8b20345b5b3f4f6d702a9d2f8.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)  
 **考虑两种场景**


* 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;

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/ecff38b93ee5427a80417442f5c2569a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)


### 206. 反转链表:


[点我](https://bbs.csdn.net/topics/618668825).  
 **实现思路**



> 
> 使用三个指针迭代的方法，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. 链表的中间结点:


[点我](https://bbs.csdn.net/topics/618668825).  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/741ac587e9b3439ca375015644ee3f2a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)



> 
> 快慢指针解法，快指针走两步慢指针走一步，当快指针走到链表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个结点:


[点我](https://bbs.csdn.net/topics/618668825).  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/48b10f82084f4e47842d18909c815e6b.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)



> 
> 快指针先走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. 合并两个有序链表


链接: [点我](https://bbs.csdn.net/topics/618668825).  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/e73bbe6ebd6a48d28d0af1c6f336f369.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)



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

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 链表的回文结构


链接: [点我](https://bbs.csdn.net/topics/618668825) .  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/f4963ab123324c4a88500243825bc845.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)



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

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;
}

};


![在这里插入图片描述](https://img-blog.csdnimg.cn/b8e9fdb259b544dca97dfb90e3d02611.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)  
 160. 相交链表  
 链接: [点我](https://bbs.csdn.net/topics/618668825).



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

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
//记录链表的长度
int lenA = 0,lenB = 0;
struct ListNode *curA = headA;
struct ListNode *curB = headB;
while(curA->next)
{
lenA++;
curA = curA->next;
}
while(curB->next)
{
lenB++;
curB = curB->next;
}
//如果不相遇那么链表的最后一个结点一定不同
if(curA != curB)
return NULL;
//定义长的链表，定义短的链表
struct ListNode * longlist = headA, *shortlist = headB;
int gap = abs(lenB - lenA);
if(lenA < lenB)
{
longlist = headB;
shortlist = headA;
}
//长链表先走gap步
while(gap–)
{
longlist = longlist->next;
}
//最后一起走
while(longlist != shortlist)
{
longlist = longlist->next;
shortlist = shortlist->next;
}

return longlist;

}


### 141. 环形链表


链接: [点我](https://bbs.csdn.net/topics/618668825).  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/ab93b169a750485fbf1ca357879d21e8.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)



> 
> 快慢指针解法，快指针走两步，慢指针走一步，当他们相遇了，就能证明链表是环形链表，如果fast走到NULL的位置或者fast的下一个结点是空了，那么链表就不为环形
> 
> 
>

bool hasCycle(struct ListNode *head) {
struct ListNode * fast = head;
struct ListNode * slow = head;
while(fast && fast->next)
{
fast = fast->next->next;
slow = slow->next;
if(fast == slow)
{
return true;
}
}
return false;
}


延申问题


* 1、为什么slow走一步，fast走两步，它们一定会在环里面相遇，会不会永远追不上，请证明
* 2、slow走一步，fast走3步？走4步？走n步行不行？请证明！
* 3、求环的入口点


![在这里插入图片描述](https://img-blog.csdnimg.cn/98c37915789e4b3aad5ada9a4acb3024.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)  
 不会，假设slow进环的时候fast跟slow的差距是N， 紧接着追击的过程，fast往前走2步，slow走1步，它们每次一走，它们之间的距离缩小1，N-1 N-2 … 2 1 0，直到等于0的时候就相遇了


**2、slow走一步，fast走3步？走4步？走n步行不行？请证明！**  
 假设slow进环的时候fast跟slow的差距是N， 紧接着追击的过程，fast往前走3步，slow走1步，它们每次一走，它们之间的距离缩小2，会分两种情况，如果是奇数个，如果是偶数个呢？如果是偶数个可以相遇，如果是奇数（-1）个并不会相遇，假设环的大小是C，那么slow和falst的差距就是C-1了，如果C-1恰好是奇数就永远追不上  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/52a523b8f872437dbf939504a98f12a6.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_14,color_FFFFFF,t_70,g_se,x_16)  
 总结：如果slow进环时，slow跟fast的差距是奇数，且环的长度是偶数，那么它们两个再环里面就会一直打圈



> 
> 解题思路：  
>  将fast和slow的相遇点找出来，meet表示相遇点，从相遇点meet开始  
>  head走一步meet走一步，如果他们相遇了，那么这就是入口点
> 
> 
>

struct ListNode *detectCycle(struct ListNode *head) {
struct ListNode * fast = head;
struct ListNode * slow = head;
while(fast && fast->next)
{
fast = fast->next->next;
slow = slow->next;
//相遇
if(fast == slow)
{
//相遇后,meet从相遇点开始走，head从起点开始走，
struct ListNode *meet = fast;
while(head != meet)
{
head = head->next;
meet = meet->next;
}
//当head和meet相遇了，这就是入口点
if(meet == head)
{
return meet;
}
}
}

return NULL;

}


### 138. 复制带随机指针的链表:


[点我](https://bbs.csdn.net/topics/618668825).  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/902fe371b4564389af5068e9dc50c620.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)



> 
> 解题思路：  
>  要想复制一份链表比较得保证新链表的结点关系和原链表保持一致，并且新链表的每个结点的值以及结点中两个指针的指向都必须与原链表结点一样，将拷贝链表的结构构建出来后，同步拷贝链表和原链表两个指针的指向，最后将拷贝链表拆解下来，同时还原原链表结点的链接的关系，最后返回拷贝链表的头
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/34e64913983f4acd8d2396f011ecc2bf.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)

struct Node* copyRandomList(struct Node* head) {
if(head == NULL)
{
return NULL;
}
struct Node* cur = head;
//建立拷贝结点的关系
while(cur)
{
struct Node* next = cur->next;
struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
copy->val = cur->val;
copy->next = next;
cur->next = copy;
cur = next;
}
//同步拷贝结点的随机指针
cur = head;
while(cur)
{
struct Node* copy = cur->next;
struct Node* next = copy->next;
if(cur->random == NULL)
{
copy->random = NULL;
}
else
{
copy->random = cur->random->next;
}
cur = next;
}
//创建哨兵位头节点，新链表的尾结点

img
img

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

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

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

t Node* next = cur->next;
struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
copy->val = cur->val;
copy->next = next;
cur->next = copy;
cur = next;
}
//同步拷贝结点的随机指针
cur = head;
while(cur)
{
struct Node* copy = cur->next;
struct Node* next = copy->next;
if(cur->random == NULL)
{
copy->random = NULL;
}
else
{
copy->random = cur->random->next;
}
cur = next;
}
//创建哨兵位头节点，新链表的尾结点

[外链图片转存中…(img-9vqrjJgo-1715537810104)]
[外链图片转存中…(img-Lo8wDbrG-1715537810104)]

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

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

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

2401_84975411
关注
  • 21
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2024 华为OD机试（C语言）真题【A卷+B卷+C卷+D卷】目录
MISAYAONE的博客
02-25 7万+
华为OD机试真题（C语言）
力扣题库刷题笔记34-在排序数组中查找元素的第一个和最后一个位置
07-07
力扣题库刷题笔记34-在排序数组中查找元素的第一个和最后一个位置
2024年C C++最新单链表C语言实现附加力扣题_c 力扣 遍历 单链表(1)，2024年最新C C++面试项目源码
2401_84976619的博客
05-13 978
/如果不相遇那么链表的最后一个结点一定不同。//找到中间结点整体逆置，最后比较。//定义长的链表，定义短的链表。//pos等于ps，头删。//长链表先走gap步。//移除指定位置之后。
从C语言到C++_39(C++笔试面试题)next_permutation刷力扣
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
09-08 399
从C语言到C++_39（C++笔试面试题）next_permutation。力扣88.合并两个有序数组+349.两个数组的交集+60.排列序列+46.全排列，下一篇：零基础Linux_1（前期准备）Linux发展史和环境安装。
从C语言到C++_18(stack和queue的常用函数+相关练习)力扣
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
06-11 2274
从C语言到C++_18(stack和queue的常用函数+相关练习)力扣：155+946(剑指offe31)+150+225+232。
Leet Code_力扣原题_leetcode官网_
10-01
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为准备技术面试和提升编程技能而设计。它提供了各种算法和数据结构题目，涵盖了多种编程语言，包括但不限于Java、Python、C++和JavaScript。力扣上的问题...
力扣-LeetCode全套2000题目解答C++和Java版.rar
06-26
这个压缩包文件包含的是LeetCode上2000道编程题目的C++和Java解法，覆盖了从第1题到第2000题的广泛范围。这些题目涵盖了数据结构、算法、设计模式等多个IT领域的核心知识点，是提升编程技术的宝贵资源。 首先，让...
Python算法题源代码-LeetCode(力扣)-二叉树中的最大路径和
02-21
力扣热题Python源代码 题目：124. 二叉树中的最大路径和 二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不...
Python算法题源代码-LeetCode(力扣)-在排序数组中查找元素的第一个和最后一个位置
03-09
力扣热题Python源代码 题目34. 在排序数组中查找元素的第一个和最后一个位置 给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。 如果数组中不...
C语言——冒泡排序法与简单选择排序法及其区别
最新发布
weixin_45720999的博客
07-13 629
它通过两层嵌套的循环来实现：外层循环控制排序的总轮数，内层循环负责在每轮中进行实际的元素比较和交换。每完成一轮内层循环，数组中的最大元素就会“冒泡”到它应该在的位置上，因此外层循环每次迭代时，内层循环的迭代次数可以相应减少。是一种简单直观的排序算法。它的工作原理是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
LeetCode LCR024.反转链表 经典题目 C写法
m0_63816268的博客
07-11 371
​ 使用三个指针，n1,n2,n3，n1为空，n2为头结点，n3为头结点的next。开始反转后，n1赋值给n2的next，n2赋值给n1，n3赋值给n2找到下一个反转的结点，n3找它的next遍历。如此迭代就完成了反转。​ 创建两个指针rhead和cur，rhead作为新的头，cur进行链表遍历，将每个结点头插在rhead上。
函数模板与类模板
程序员_小兵
07-12 1545
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
C++ 多态
wxk2227814847的博客
07-10 781
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
C++初探究（2）
Frenemy__的博客
07-09 1495
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C语言操作符详解
z317920的博客
07-11 625
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
C++：哈希表
m0_61088872的博客
07-12 693
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
【C++】类和对象--类，实例化，this指针
tidal_wave的博客
07-10 1013
前面的几篇文章我们介绍了命名空间，inline，nullptr等C++中常见的的基础概念。今天的文章我们来介绍一些C++中类与对象的内容。在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象：矩形、雇用记录、视频剪辑等。可以利用这些对象的相同特征为它们建立一个集合。而这个集合就称为类。类是定义同一类所有对象的变量和方法的蓝图或原型。
力扣662. 二叉树最大宽度题C语言答案
04-02
以下为力扣662. 二叉树最大宽度题的C语言答案： ``` /** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */ typedef struct Queue { struct TreeNode *node; int index; } Queue; int widthOfBinaryTree(struct TreeNode* root){ if (root == NULL) { return 0; } Queue *queue = (Queue*)malloc(sizeof(Queue)); int head = 0, tail = 0, max_width = 0; queue[tail++] = (Queue){root, 1}; while (head < tail) { int size = tail - head; int left = queue[head].index, right = queue[head + size - 1].index; max_width = fmax(max_width, right - left + 1); for (int i = 0; i < size; i++) { Queue node = queue[head++]; if (node.node->left != NULL) { queue[tail++] = (Queue){node.node->left, node.index * 2}; } if (node.node->right != NULL) { queue[tail++] = (Queue){node.node->right, node.index * 2 + 1}; } } } free(queue); return max_width; } ``` 这个答案使用了队列来进行层序遍历，同时记录每个节点在当前层的编号，使用这个编号来计算宽度。具体实现上使用了一个结构体来存储节点和编号的信息，使用两个指针来实现队列的功能。时间复杂度为O(n)，空间复杂度为O(n)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值