目录
日期：2022-10-23📅
消失的数字
题目链接：力扣
（1）求和相减法
可以把前N项的值计算出来，然后把求出来的和减去数组中的数字，这样剩下来的就是数组中缺少的数字
空间复杂度：O（1） 时间复杂度：O（N）
int missingNumber(int* nums, int numsSize){
int n=numsSize;
//等差数列求和
int Sn=n*(n+1)/2;
int i=0;
//用求和的值减去数组中的值，剩下的就是缺少的数字
for(i=0;i<numsSize;i++)
{
Sn-=nums[i];
}
return Sn;
}（2）异或法
异或的思想是相同为0，相异为1，所以我们可以把数组里的值先进行异或，得出来的值在去异或0～n的数值，结果就为缺少的数字，使用该思想时我们需要明确异或可以打乱数字顺序，只需要出现2次就为0了，简单来说1，1，3异或和1，3，1异或的值是相同的，都剩下3
空间复杂度：O（1） 时间复杂度O（N）
int missingNumber(int* nums, int numsSize){
int ret=0;
int i=0;
int n=numsSize;
//和数组里的每一个元素进行异或
for(i=0;i<numsSize;i++)
{
ret^=nums[i];
}
//然后再和实际的个数进行异或，剩下来的就是缺少的那一个
for(i=0;i<=n;i++)
{
ret^=i;
}
return ret;
}轮转数组
题目链接：力扣
（1）使用额外空间
我们需要把原数组的值赋值到新数组对应的位置即可
空间复杂度O（N） 时间复杂度O（N）
普通版
void rotate(int* nums, int numsSize, int k){
int i=0;
int* tmp=(int*)malloc(sizeof(int)*numsSize);
int j=0;
k=k%numsSize;
for(i=numsSize-k;i<numsSize;i++)
{
tmp[j++]=nums[i];
}
for(i=0;i<=numsSize-k-1;i++)
{
tmp[j++]=nums[i];
}
for(i=0;i<numsSize;i++)
{
nums[i]=tmp[i];
}
}优化版
void rotate(int* nums, int numsSize, int k){
int i=0;
int* tmp=(int*)malloc(sizeof(int)*numsSize);
int j=0;
//调整k
k=k%numsSize;
for(i=0;i<numsSize;i++)
{
//这一步是解题的关键
tmp[(i+k)%numsSize]=nums[i];
}
for(i=0;i<numsSize;i++)
{
nums[i]=tmp[i];
}
}（2）三步翻转法
翻转k前的数字，翻转k后的数字，整个数组翻转
空间复杂度O（1） 时间复杂度O（N）（每个数字被翻转2次，O（2N）=O（N））
下面图假设k=3
void Reverse(int* nums,int left,int right)
{
while(left<right)
{
int tmp=nums[left];
nums[left]=nums[right];
nums[right]=tmp;
left++;
right--;
}
}
void rotate(int* nums, int numsSize, int k){
//如果k超出了数组长度，需要调整
k=k%numsSize;
//反转k前的数字
Reverse(nums,0,numsSize-k-1);
//反转k后的数字
Reverse(nums,numsSize-k,numsSize-1);
//全部反转
Reverse(nums,0,numsSize-1);
}（3）环状替换
我们需要把整个数组想象成一个环，第一次对第0个，0+k个，0+K+K····进行移动，第二次对第1个，1+k个，1+k+k个····进行移动，我们需要一个外循环控制最初的位置，然后有一个内循环去协调内部数字的右转，注意下图箭头的个数，我们发现箭头的个数等于数组的长度，即循环结束的条件。
空间复杂度O（1） 时间复杂度O（N）
假设k=3 （注意颜色）
void swap(int* p1,int* p2)
{
int tmp=*p1;
*p1=*p2;
*p2=tmp;
}
void rotate(int* nums, int numsSize, int k){
int start=0;
//用来计算走了多少步
int count=0;
int next=0;
k=k%numsSize;
for(start=0;count<numsSize;start++)
{
int cur=start;
int prev=nums[cur];
do
{
next=(cur+k)%numsSize;
swap(&prev,&nums[next]);
cur=next;
//用来计算一共走了多少次，当count和numsSize相等的时候就是循环结束条件
count++;
}while(cur!=start);
}
}日期：2022-10-25📅
移除元素
题目链接：力扣
（1）双指针
假设定义了fast指针和slow指针，fast指针一直往前走，slow指针指向的值遇到了和指定值相同的时候就和fast指针指向的值进行替换
空间复杂度：O（N） 时间复杂度：O（N）
下图假设我要找的值为3
int removeElement(int* nums, int numsSize, int val){
int slow=0;
int fast=0;
while(fast<numsSize)
{
//值不等于查找值的时候就赋值给slow
if(nums[fast]!=val)
{
//位置相同的时候就可以不调换，避免重复调换
if(slow!=fast)
{
nums[slow]=nums[fast];
}
slow++;
}
//查找值等于fast和不等于fast时都需要fast++
fast++;
}
//最终数组的长度就是慢指针的长度
return slow;
}（2）双指针优化
定义left和right指针，left指针指向等于指定值的位置的时候就与right指针的值进行交换
空间复杂度O（1） 时间复杂度O（N） （只会遍历一次，速度更快一些）
int removeElement(int* nums, int numsSize, int val){
int left=0;
//这里right不能等于numsSize-1，因为力扣有一个条件是空数组，会发生越界
int right=numsSize;
while(left<right)
{
if(nums[left]==val)
{
nums[left]=nums[right-1];
right--;
}
else
{
left++;
}
}
return left;
}日期：2022-10-30📅
删除有序数组中的重复项
题目链接：力扣
（1）双指针
定义一个slow和fast指针，fast指针和slow指针判断值是否相等，若相等则移动fast指针，不想等就把fast指针的值给slow+1的位置
空间复杂度O（1） 时间复杂度O（N）
int removeDuplicates(int* nums, int numsSize){
int slow=0;
int fast=0;
while(fast<numsSize)
{
if(nums[fast]==nums[slow])
{
fast++;
}
//注意这里指针的移动顺序
else
{
slow++;
nums[slow]=nums[fast];
fast++;
}
}
return slow+1;
}日期：2022-11-3📅
移除链表元素
题目链接：力扣
（1）迭代法
设置一个虚拟节点（方便头删），然后定义prev,cur,next三个指针，如果cur指针等于要查找的值，就把prev指针指向next指针然后删除cur节点，否则就正常往前走
空间复杂度：O（1）时间复杂度：O（N）
假设有如下数组，查找的值为6
struct ListNode* removeElements(struct ListNode* head, int val){
if(head==NULL)
{
return head;
}
//虚拟节点，这样头删方便
struct ListNode* dummyHead=(struct ListNode*)malloc(sizeof(struct ListNode));
dummyHead->next=head;
struct ListNode* prev=dummyHead;
struct ListNode* cur=prev->next;
while(cur)
{
struct ListNode* next=cur->next;
if(cur->val==val)
{
prev->next=next;
free(cur);
cur=next;
}
else
{
prev=cur;
cur=next;
}
}
return dummyHead->next;
}日期：2022-11-4📅
反转链表
题目链接：力扣
（1）迭代法
思想：定义三个指针，prev，cur和next，next用来保存cur的下一个节点，cur的下一个节点去要指向prev，当cur等于空的时候循环结束
空间复杂度：O（1） 时间复杂度：O（N）
struct ListNode* reverseList(struct ListNode* head){
struct ListNode* cur=head;
struct ListNode* prev=NULL;
while(cur!=NULL)
{
//保存下一个的值
struct ListNode* next=cur->next;
cur->next=prev;
prev=cur;
cur=next;
}
return prev;
}链表的中间结点
题目链接：力扣
（1）快慢指针
思想：慢指针一次走一步，快指针一次走两步，当快指针走到空时，返回慢指针的结点
空间复杂度：O（1） 时间复杂度：O（N）
struct ListNode* middleNode(struct ListNode* head){
struct ListNode* slow=head;
struct ListNode* fast=head;
//防止结点个数为奇数
while(fast!=NULL&&fast->next!=NULL)
{
slow=slow->next;
fast=fast->next->next;
}
return slow;
}链表中倒数第k个节点
题目链接：力扣
（1）双指针
思想：定义两个指针，让fast指针比slow指针快k个位置，然后一起往后走，当fast指针指向空时，返回slow指针
空间复杂度：O（1） 时间复杂度：O（N）
假设k等于2
struct ListNode* getKthFromEnd(struct ListNode* head, int k){
struct ListNode* fast=head;
struct ListNode* slow=head;
//让fast和slow的间距控制为k个
while(k--)
{
fast=fast->next;
}
while(fast!=NULL)
{
fast=fast->next;
slow=slow->next;
}
return slow;
}合并两个有序链表
题目链接：力扣
（1）迭代法
思想：plist1和plist2依次比较值，然后把小的尾插到新的head里面
空间复杂度：O（1）（这里并不会浪费空间，因为链表是连接起来的）
时间复杂度：O（N+M）（需要遍历两个链表，所以是两个链表加起来的长度）
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
//如果某一个链表为空就返回另一个链表
if(list1==NULL)
{
return list2;
}
if(list2==NULL)
{
return list1;
}
//新开辟一个头
struct ListNode* head=(struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* tail=NULL;
while(list1!=NULL&&list2!=NULL)
{
if(list1->val<list2->val)
{
//尾插为第一个结点的时候需要判断
if(tail==NULL)
{
head=tail=list1;
}
else
{
tail->next=list1;
tail=list1;
}
list1=list1->next;
}
else
{
if(tail==NULL)
{
head=tail=list2;
}
else
{
tail->next=list2;
tail=list2;
}
list2=list2->next;
}
}
//把尾在连接剩余的结点
if(list1!=NULL)
{
tail->next=list1;
}
if(list2!=NULL)
{
tail->next=list2;
}
return head;
}
173
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
