leetcode双指针习题

leetcode双指针习题

移除元素

链接

思路1

找一个删一个
一个一个元素挨着遍历,等于val留下,不等于删去
时间复杂度: O(n^2)
空间复杂度: O(1)

参考代码

int removeElement(int* nums, int numsSize, int val)
{
    int i=0;
    while(i<numsSize)
    {
        if(nums[i]==val)
        {
            int begin=i;
            while(begin<numsSize-1)
            {
                nums[begin]=nums[begin+1];
                ++begin;
            }
            numsSize--;
        }
        else
        {
            i++;
        }
    }
    return numsSize;  
}

思路2

以时间换空间的思想
新开辟一块空间,将原数组中不等于val的数赋值到新数组中,后将新数组拷贝回原数组

时间复杂度: O(n)
空间复杂度: O(n)

参考代码

int removeElement(int* nums, int numsSize, int val){

    int src=0;
    int dst=0;
    
    //开辟一个新的数组
    int tmp[100];
    
    //挪动数据
    while(src<numsSize)
    {
        if(nums[src] == val)
        {
            src++;
        }
        else
        {
           tmp[dst++] = nums[src++];
        }
    }
    
    //拷贝回原数组                                      
    for(int i=0;i<dst;i++)
    {
        nums[i]=tmp[i];
    }
    
    return dst;
}

思路3(双指针)

在思路2基础上变形,在原数组上采用两个指针完成, 不等于val保留, 等于val删去

时间复杂度: O(n)
空间复杂度: O(1)

过程图:

参考代码1

int removeElement(int* nums, int numsSize, int val){

    int src=0;
    int dst=0;
    
    //挪动数据
    while(src<numsSize)
    {
        if(nums[src] == val)
        {
            src++;
        }
        else
        {
           nums[dst] = nums[src];
           dst++;
           src++;
        }
    }
    
    return dst;
}

参考代码2(简洁版)

int removeElement(int* nums, int numsSize, int val){

    int src=0;
    int dst=0;
    
    while(src<numsSize)
    {
        if(nums[src] != val)
           nums[dst++] = nums[src];
           
           src++;
    }
    
    return dst;
}

删除有序数组中的重复项

链接

思路1

原数组中的元素一一比较,删除相同的值,挪动数据

时间复杂度: O(n^2)
空间复杂度: O(1)

参考代码

int removeDuplicates(int* nums, int numsSize)
{
      for(int i=0;i<numsSize-1;i++)
      {
          if(nums[i]==nums[i+1])
          {
              for(int j=i;j<numsSize-1;j++)
              {
                   nums[j]=nums[j+1];
              }
              
              i--;
              numsSize--;
          }
      }
      return numsSize;
}

思路2

以时间换空间的思想
新开辟一块空间,先将原数组的首元素赋给新数组,遇到不同的值赋给新数组,相同的值直接走,最后将新数组拷贝到原数组

时间复杂度: O(n)
空间复杂度: O(n)

参考代码

int removeDuplicates(int* nums, int numsSize)
{
    int* tmp = (int*)malloc(numsSize * sizeof(int));
    tmp[0] = nums[0];
    int j = 0;
    int i = 1;

    while(i<numsSize)
    {
        if (nums[i] == tmp[j])
        {
            ++i;
        }
        else
        {
            ++j;
            tmp[j] = nums[i];
            ++i;
        }
    }

    for (int i = 0; i <numsSize; i++)
    {
        nums[i] = tmp[i];
    }
    return j + 1;

}

思路3(双指针)

在思路2基础上变形,在原数组上采用两个指针完成, 遇到两个指针指向相同的值时,一个指针src走,一个指针dst不走
指向不同的值时,先++dst,将src指向的值赋给dst指向的位置,后src++

时间复杂度: O(n)
空间复杂度: O(n)

参考代码

int removeDuplicates(int* nums, int numsSize)
{
    int src=0,dst=0;

    while(src<numsSize)
    {
        if(nums[src]== nums[dst])
        {
            src++;
        }
        else
        {
            nums[++dst]=nums[src++];
        }
    } 
    
    return dst+1;
}

合并两个有序数组

链接

思路1

直接合并后排序

时间复杂度: O((n+m)log(n+m))
空间复杂度: O(log(m+n))

参考代码

int cmp (const void * a, const void * b)
{
  return ( *(int*)a - *(int*)b );
}
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{
    //合并
    int j=0;
     for(int i=m;i<m+n;i++)
     {
         nums1[i]=nums2[j];
         j++;
     }

     //排序
     qsort(nums1,nums1Size,sizeof(int),cmp);
}

思路2

以时间换空间的思想
新开辟一块空间,取小的尾插(先将小的值保存起来然后放到新数组中),再将新数组拷贝到原数组

时间复杂度: O(n)
空间复杂度: O(n)

参考代码

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{
   int sorted[m+n];
   int p1=0;
   int p2=0;
   int cur=0;

   while(p1<m || p2<n)
   {
      if(p1==m)             //数组1已经结束
      {
          cur=nums2[p2++];
      }
      else if(p2==n)        //数组2已经结束
      {
          cur=nums1[p1++];
      }
      else if(nums1[p1]<nums2[p2])   //数组1小于数组2
      {
          cur=nums1[p1++];
      }
      else                           //数组2小于数组1
      {
          cur=nums2[p2++];
      }

      sorted[p1+p2-1]=cur;
   }

   for(int i=0;i<m+n;++i)
   {
       nums1[i]=sorted[i];
   }
}

思路3(双指针)

类似于归并排序(链接: 链接 )的思路:取小的尾插
这里因为是插入到有元素的数组,采用取大的尾插

在思路2基础上变形,在原数组上采用两个指针进行取大的尾插
注意nums2数组元素均小于nums1数组元素的情况,均未尾插上时,最后处理一下,直接拷贝过去

时间复杂度: O(n)
空间复杂度: O(1)

参考代码

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{
    int i1=m-1;
    int i2=n-1;
    int j=m+n-1;

    //取大的尾插
    while(i1>=0 && i2>=0)
    {
        if(nums1[i1]>nums2[i2])   
        {
            nums1[j--]=nums1[i1--];
        }
        else
        {
            nums1[j--]=nums2[i2--];
        }
    }

    //nums2数组元素均小于nums1数组元素,在上面均未尾插上
    while(i2>=0)
    {
        nums1[j--]=nums2[i2--];
    }

}

总结

本文中的题目其他思路仅作为参考,比较推荐学习双指针思路

所谓双指针思路就是用两个下标来控制数组,在原数组中进行操作