顺序表、链表相关OJ题（2）

创作不易，友友们给个三连吧！！

一、旋转数组（力扣）

经典算法OJ题：旋转数组

思路1：每次挪动1位，右旋k次

时间复杂度：o(N^2)       

右旋最好情况：k是n的倍数，相当于不右旋，此时为o（1）

右旋最坏情况：k%n==n-1,此时为o（N^2）

空间复杂度:o(1)

void rotate(int* nums, int numsSize, int k) 
{k%=numsSize;while(k){int temp=nums[numsSize-1];//从后往前挪 for(int i=numsSize-1;i>0;i--){nums[i]=nums[i-1];//最后一个是nums[1]=num[0]}nums[0]=temp;k--;//旋转一次就减一次}
}

注：这是常规思路，但是由于空间复杂度太高，数组个数特别多的时候，在力扣运行的时候超出了时间限制！

思路2：创建一个和nums一样长度的新数组，将nums数组的后k个元素，先按顺序放进新数组里，然后剩下前面的n-k个元素，再按顺序放进新数组,最后再将新数组的数据拷贝到nums中

时间复杂度：o(N)

空间复杂度：o(N)

void rotate(int* nums, int numsSize, int k) 
{k%=numsSize;int arr[numsSize];//vs不支持变长数组，但是牛客支持，如果是vs只能使用动态数组。memcpy(arr,nums+numsSize-k,sizeof(int)*k);//nums的后k个按顺序拷贝到新数组的前面memcpy(arr+k,nums,sizeof(int)*(numsSize-k));//nums的前n-k个按顺序拷贝到新数组的后面memcpy(nums,arr,sizeof(int)*numsSize);//新数组完全拷贝到nums数组中
}

思路3：前n-k个元素逆置，后k个元素逆置，再整体逆置

时间复杂度：o(N)

空间复杂度：o(1)

void reverse (int *arr,int left,int right)//实现逆序函数
{int temp=0;while(left<right){temp=arr[left];arr[left]=arr[right];arr[right]=temp;left++;right--;}
}
void rotate(int* nums, int numsSize, int k) 
{k%=numsSize;reverse(nums,0,numsSize-k-1);//前n-k个元素逆序reverse(nums,numsSize-k,numsSize-1);//后k个逆序reverse(nums,0,numsSize-1);//完全逆序
}

二、消失的数字（力扣）

经典算法OJ题：消失的数字

思路1：先进行排序，如果后一个不等于前一个+1，就可以找到消失的数据，但是目前掌握的排序中，冒泡排序的时间复杂度是o（N^2），而qsort的时间复杂度是o（logN+N）,均不符合题意，这里不做考虑！

思路2：让0和0-numsSize的所有数都异或一遍，再和数组中的所有元素异或一边，最后得到的结果就是消失的数（利用了a^a=0，a^0=a的结论）

时间复杂度：o(N)

空间复杂度：o(1)

int missingNumber(int* nums, int numsSize)
{
int x=0;
for(int i=0;i<numsSize;i++)
{x^=i;x^=nums[i];
}
x^=numsSize;//还多了一个数
return x;
}

思路3：0-numsSize的所有数相加，然后减去数组中的所有元素之和，得到的就是消失的数字。

时间复杂度：o(N)

空间复杂度：o(1)

int missingNumber(int* nums, int numsSize)
{int sum=0;//记录
for(int i=0;i<numsSize;i++)
{sum+=i;sum-=nums[i];
}
sum+=numsSize;
return sum;
}

三、链表中倒数第k个结点（牛客）

经典算法OJ题：链表中倒数第k个结点

思路1：第一次循环计算结点的个数count，然后求倒数第k个就是正数的第count-k个结点

空间复杂度:o(N)

时间复杂度:o(1)

 typedef struct ListNode ListNode;
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ){
ListNode* pcur= pListHead;
int count=0;//统计结点
while(pcur)
{pcur=pcur->next;count++;
}
if(count<k)
return NULL;//考虑链表为NULL，以及k大于链表结点数
pcur= pListHead;
for(int i=0;i<count-k;i++)
pcur=pcur->next;
return pcur;
}

思路2：（快慢指针）fast指针先走k步，然后fast和slow同时走，始终保持k的距离，当fast走到NULL的时候，slow对应的恰好就是倒数第k个结点

空间复杂度:o(N)

时间复杂度:o(1)

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ){
struct ListNode*fast=pListHead,*slow=pListHead;
while(k)
{//考虑k大于结点数的情况，此时链表很早就为空了if(fast==NULL)return NULL;fast=fast->next;k--;
}
//同时走，直到fast为NULL，此时slow指向倒数第k个结点
while(fast)
{fast=fast->next;slow=slow->next;
}
//如果k<=0.那么第一个while循环不会进入，
//fast和slow同时走，最后都会指向空，所以不需要额外判断
return slow;
}

思路3：直接反转链表，然后直接找第k个结点

该方法直接改变了链表结构，使得phead变成了一个尾结点，与其他结点建立不起联系，所以该思路不行（尽量不要去改变原先链表的结构）在力扣中过不了。

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ){
//直接反转链表，然后找第k个结点
if(pListHead==NULL)
return NULL;
struct ListNode*p1=NULL;
struct ListNode*p2=pListHead;
struct ListNode*p3=pListHead->next;
int count=0;//用来数数
while(p2)
{p2->next=p1;p1=p2;p2=p3;if(p3)p3=p3->next;++count;
}
//此时的p1就是新链表的头结点
if(k<=count||k>count)
return NULL;
while(--k)
{
p1=p1->next;
}
return p1;
}

四、相交链表（力扣）

经典算法OJ题：相交链表

思路1：A链表逐个结点与B链表比较，如果存在相等，则就是相交结点（注：要比较指针而不能比较值，因为值是可以重复的）

空间复杂度:o(N^2)

时间复杂度:o(1)

typedef struct ListNode ListNode;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{ListNode* pcurA=headA;ListNode* pcurB=headB;while(pcurA){while(pcurB){if(pcurA==pcurB)return pcurA;pcurB=pcurB->next;}pcurB=headB;pcurA=pcurA->next;}return NULL;
}

思路2：长的链表往后走长度差，再同时走，直到相等就是相交点

空间复杂度:o(N)

时间复杂度:o(1)

typedef struct ListNode ListNode;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{ListNode * Apcur=headA;//用来遍历A链表ListNode * Bpcur=headB;//用来遍历A链表int a=0;//数a长度int b=0;//数b长度
while(Apcur)
{
Apcur=Apcur->next;
a++;
}
while(Bpcur)
{
Bpcur=Bpcur->next;
b++;
}
//找最小数，写俩while循环，只要大的数才可以走，小的走不了
int m=a>b?b:a;
while(a-m)
{headA=headA->next;a--;
}
while(b-m)
{headB=headB->next;b--;
}
while(headA)
{if(headA==headB)return headA;headA=headA->next;headB=headB->next;
}
return NULL;
}

五、链表的回文结构（牛客）

经典算法OJ题：链表的回文结构

思路1：找到中间结点，然后逆置后半段,然后将后续半段和前半段的链表同时走，如果其中一个走到空了值依旧是相等的，那么就是回文结构！！

空间复杂度:o(N)

时间复杂度:o(1)

ListNode *middleNode(struct ListNode *phead)
{
struct ListNode *fast,*slow;
fast=slow=phead;
while(fast!=NULL&&fast->next!=NULL)
{
fast=fast->next->next;
slow=slow->next;
}
return slow;
}
struct ListNode* reverseList(struct ListNode* head)
{//链表为空的时候if(head==NULL)return head;//链表不为空的时候，创建3个指针，分别指向前驱、当前、后继结点
struct ListNode*p1,*p2,*p3;
p1=NULL;//前驱
p2=head;//当前
p3=head->next;//后继
while(p2)
{//改变指向
p2->next=p1;
//向后挪动
p1=p2;
p2=p3;
//考虑p3为NULL的时候
if(p3)
p3=p3->next;
}
return p1;
}
class PalindromeList {
public:bool chkPalindrome(ListNode* A) {struct ListNode *mid=middleNode(A);//找中间结点struct ListNode *rmid=reverseList(mid);//逆序后半段while(rmid){if(A->val!=rmid->val)return false;A=A->next;rmid=rmid->next;}return true;}
};

六、随机链表的复制（力扣）

经典算法OJ题：随机链表的复制

思路1：1、插入拷贝结点到原结点的后面，2、控制拷贝结点的random，3、拷贝结点解下来，尾插到新链表上，同时恢复原链表

空间复杂度:o(N)

时间复杂度:o(N)

typedef struct Node Node;
Node* copyRandomList(Node* head) 
{if(head==NULL)return NULL;//将拷贝结点放在原结点的后面Node*pcur=head;while(pcur){Node*copy=(Node*)malloc(sizeof(Node));//拷贝结点copy->val=pcur->val;//插入copy->next=pcur->next;pcur->next=copy;//迭代pcur=pcur->next->next;}//控制拷贝结点的random指针pcur=head;while(pcur){//有可能random指向NULLNode* copy=pcur->next;if(pcur->random==NULL)copy->random=NULL;else//拷贝结点的random恰好在原结点的random后面copy->random=pcur->random->next;//迭代pcur=pcur->next->next;}//将拷贝结点解下来尾插到新链表上pcur=head;Node*newhead,*newtail,*temp;newhead=newtail=(struct Node*)malloc(sizeof(struct Node));temp=NULL;//用来记录遍历点while(pcur){Node* copy=pcur->next;temp=copy->next;//记录遍历点newtail->next=copy;//尾插newtail=newtail->next;//修复原链表pcur->next=temp;//继续遍历pcur=pcur->next;}Node*ret=newhead->next;//销毁哨兵结点前记住头结点free(newhead);newhead=NULL;return ret;
}

思路2：暴力拷贝链表，然后看原结点的random是原链表的第几个结点，对应的就是拷贝链表的的第几个结点

空间复杂度:o(N^2)

时间复杂度:o(N)

typedef struct Node Node;
Node* copyRandomList(Node* head) 
{if(head==NULL)return NULL;Node*pcur=head;Node*newhead,*newtail;newhead=newtail=(Node*)malloc(sizeof(Node));//哨兵结点while(pcur){Node*newnode=(Node*)malloc(sizeof(Node));newnode->val=pcur->val;newtail->next=newnode;newtail=newnode;//迭代pcur=pcur->next;}newtail->next=NULL;//要记住最后有个NULL；pcur=head;//回到链表头Node*newpcur=newhead->next;//用来遍历新链表头while(pcur){int s=0;//记录节点与head的距离Node*flag=head,*temp=pcur->random;//temp记住random结点while(flag!=temp){++s;flag=flag->next;}flag=newhead->next;//回到新链表的头while(s--)flag=flag->next;//找到了，就接上newpcur->random=flag;pcur=pcur->next;newpcur=newpcur->next;}Node*ret=newhead->next;free(newhead);newhead=NULL;return ret;
}

七、带环链表的快慢指针追击问题（力扣）

7.1 判断链表中是否有环

经典算法OJ题：判断链表是否带环

思路：快慢指针追击

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

7.2 返回链表开始入环的第一个结点

思路1：利用相遇点到入口点距离等于链表头到入口点距离的结论

 typedef struct ListNode ListNode;
struct ListNode *detectCycle(struct ListNode *head)
{ListNode*fast,*slow;fast=slow=head;while(fast&&fast->next){slow=slow->next;fast=fast->next->next;//相等，说明相遇了，链表带环if(slow==fast){ListNode*meet=slow;while(meet!=head){meet=meet->next;head=head->next;}return meet;}}  return NULL;
}

思路2:在相遇点将带环链表拆开，转化成求链表相交结点的问题

typedef struct ListNode ListNode;struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{ListNode * Apcur=headA;//用来遍历A链表ListNode * Bpcur=headB;//用来遍历A链表int a=0;//数a长度int b=0;//数b长度
while(Apcur)
{
Apcur=Apcur->next;
a++;
}
while(Bpcur)
{
Bpcur=Bpcur->next;
b++;
}
//找最小数，写俩while循环，只要大的数才可以走，小的走不了
int m=a>b?b:a;
while(a-m)
{headA=headA->next;a--;
}
while(b-m)
{headB=headB->next;b--;
}
while(headA)
{if(headA==headB)return headA;headA=headA->next;headB=headB->next;
}
return NULL;
}
struct ListNode *detectCycle(struct ListNode *head)
{ListNode*fast,*slow;fast=slow=head;while(fast&&fast->next){slow=slow->next;fast=fast->next->next;if(slow==fast){//将带环链表的环拆开ListNode*newhead=slow->next;slow->next=NULL;return getIntersectionNode(newhead,head);}}return NULL;
}

7.3 追击问题扩展

根据前两题可以知道对于带环的链表，fast走2步，slow走1步

1、必然会相遇，不会错过

2、L=（n-1）*C+（C-x）   一个指针从相遇点走，一个指针从链表头走，最后会在入口点相遇

如果fast走3步，slow走1步，可以得到什么结论？？

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/458498.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【力扣】快乐数，哈希集合+快慢指针+数学

【力扣】快乐数，哈希集合+快慢指针+数学

快乐数原题地址 方法一&#xff1a;哈希集合 定义函数getNext(n)&#xff0c;返回n的所有位的平方和。一直执行ngetNext(n)&#xff0c;最终只有2种可能&#xff1a; n停留在1。无限循环且不为1。 证明&#xff1a;情况1是存在的&#xff0c;如力扣的示例一&#xff1a; 接…
阅读更多...
P1808 单词分类

P1808 单词分类

P1808 单词分类 题目描述 Oliver 为了学好英语决定苦背单词&#xff0c;但很快他发现要直接记住杂乱无章的单词非常困难&#xff0c;他决定对单词进行分类。 两个单词可以分为一类当且仅当组成这两个单词的各个字母的数量均相等。 例如 AABAC&#xff0c;它和 CBAAA 就可以…
阅读更多...
DAY14之二叉树理论基础及递归遍历和迭代遍历

DAY14之二叉树理论基础及递归遍历和迭代遍历

理论基础 满二叉树 满二叉树&#xff1a;如果一棵二叉树只有度为0的结点和度为2的结点&#xff0c;并且度为0的结点在同一层上&#xff0c;则这棵二叉树为满二叉树。 如图所示&#xff1a; 这棵二叉树为满二叉树&#xff0c;也可以说深度为k&#xff0c;有2^k-1个节点的二叉…
阅读更多...
2024年微信公众号链接爬取

2024年微信公众号链接爬取

通过输入&#xff08;或文件导入&#xff09;公众号名称&#xff0c;即可爬取该公众号所有历史文章。 通过公众号官方网站调用API&#xff0c;打开开发者工具后发现有 打开后发现有搜索结果的fakeid&#xff0c;这是每个公众号的标识。 点击某公众号后出现 这是具体公众号文章…
阅读更多...
Linux【docker 设置阿里源】

Linux【docker 设置阿里源】

文章目录 一、查看本地docker的镜像配置二、配置阿里镜像三、检查配置 一、查看本地docker的镜像配置 docker info一般没有配置过是不会出现Registry字段的 二、配置阿里镜像 直接执行下面代码即可&#xff0c;安装1.10.0以上版本的Docker客户端都会有/etc/docker 1.建立配置…
阅读更多...
Vue3.4+element-plus2.5 + Vite 搭建教程整理

Vue3.4+element-plus2.5 + Vite 搭建教程整理

一、 Vue3Vite 项目搭建 说明&#xff1a; Vue3 最新版本已经基于Vite构建&#xff0c;关于Vite简介&#xff1a;Vite 下一代的前端工具链&#xff0c;前端开发与构建工具-CSDN博客 1.安装 并 创建Vue3 应用 npm create vuelatest 创建过程可以一路 NO 目前推荐使用 Vue R…
阅读更多...
Java+微信小程序实现智慧家政系统 JAVA+Vue+SpringBoot+MySQL

Java+微信小程序实现智慧家政系统 JAVA+Vue+SpringBoot+MySQL

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块三、系统展示四、核心代码4.1 查询家政服务4.2 新增单条服务订单4.3 新增留言反馈4.4 小程序登录4.5 小程序数据展示 五、免责说明 一、摘要 1.1 项目介绍 基于微信小程序JAVAVueSpringBootMySQL的智慧家政系统&#xff0…
阅读更多...
阿里云游戏服务器多少钱一个月？

阿里云游戏服务器多少钱一个月？

阿里云游戏服务器租用价格表&#xff1a;4核16G服务器26元1个月、146元半年&#xff0c;游戏专业服务器8核32G配置90元一个月、271元3个月&#xff0c;阿里云服务器网aliyunfuwuqi.com分享阿里云游戏专用服务器详细配置和精准报价&#xff1a; 阿里云游戏服务器租用价格表 阿…
阅读更多...
2024图像消除相关论文大集合

2024图像消除相关论文大集合

28篇图像填充/Inpainting相关论文 1 CR-Fill: Generative Image Inpainting with Auxiliary Contextual Reconstruction ICCV2021 吐槽DeepFillv2 with CA layer&#xff0c;由于缺乏对缺失区域与已知区域之间对应关系的监督信号&#xff0c;可能无法找到合适的参考特征&…
阅读更多...
LeetCode130：被围绕的区域（图的简化版之网格结构上的DFS）

LeetCode130：被围绕的区域（图的简化版之网格结构上的DFS）

题目 注意&#xff1a; 1 < m, n < 200 board[i][j] 为 ‘X’ 或 ‘O’ 思路 根据一般网格结构上的DFS&#xff0c;或者说岛屿问题&#xff0c;第一反应很容易想到找出所有的‘O’然后开始DFS遍历&#xff0c;改为‘X’。 但是这里有个联通的问题&#xff0c;如果这个…
阅读更多...
使用easyExcel 定义表头 字体 格式 颜色等，定义表内容，合计

使用easyExcel 定义表头 字体 格式 颜色等，定义表内容，合计

HeadStyle 表头样式注解 HeadFontStyle 表头字体样式 HeadStyle(fillPatternType FillPatternTypeEnum.SOLID_FOREGROUND, fillForegroundColor 22) HeadFontStyle(fontHeightInPoints 12) 以下为实现效果
阅读更多...
华视 CVR-100UC 身份证读取 html二次开发模板

华视 CVR-100UC 身份证读取 html二次开发模板

python读卡&#xff1a;python读卡 最近小唐应要求要开发一个前端的身份证读卡界面&#xff0c;结果华视CVR-100UC 的读取界面是在是有点&#xff0c;而且怎么调试连官方最基本的启动程序都执行不了。CertReader.ocx 已成功&#xff0c;后面在问询一系列前辈之后&#xff0c;大…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023