重生之“我打数据结构，真的假的？”--1.顺序表

1.本系列主要用于记录本菜鸟写leetcode的感悟

希望各位大佬多多指教（doge）

2.顺序表介绍

顺序表的本质还是数组，是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

3.力扣习题

3.1-- 27.移除元素

. - 力扣（LeetCode）

思路：1.设定两个指针l,r;l先指向数组第一位 ；

2.若l*所指为为val，r*指向l*下一位；

在r*所指不为val前，r*一直右移

3.l与r所指交换，l*右移

 

int removeElement(int* nums, int numberSize,int val) {
    int l=0;
    int r=0;
    int flag;
    int n=0;
for(l=0;l<numberSize;l++)
{
   if(nums[l]==val&&l<numberSize-1)
   {
     r=l+1;
    for(r=l+1;r<numberSize;r++)
       {
        if(nums[r]!=val)
          {
            flag=nums[r];
            nums[r]=nums[l];
            nums[l]=flag;
            n++;
            break;
          }
       }
   }
    else if(nums[l]!=val)
    n++;
}
 return n;
}

3.2--189.轮转数组 

. - 力扣（LeetCode）

 

原思路：（以示例1）

1. 先取7，将所有数字（除了7）后移一位；将7插入首位；【7，1，2，3，4，5，6】

2.再取6，重复操作，再取5..........

总结：

1.未考虑若k>=numsSize时，k应当取k%numsSize，因为轮转numsSize次后，相当于没变；

2.时间复杂度问题，每次移动末位元素时，前面所有元素都要后移；若k很大，则会超时。

新思路：（以示例1）

1.分割数组【1，2，3，4|5，6，7】

2.前半，后半数组分别倒置【4，3，2，1|7，6，5】

3.然后整个数组倒置【5，6，7，1，2，3，4】

（可以用数学方法证明）

void rotate(int* nums, int numsSize, int k) {
    int flag;
    int l=0;
    int r=0;
    int q=0;
    if(k<= numsSize)
    flag=numsSize-k;
   else
   flag= numsSize-(k%numsSize);
   if(numsSize!=1)
    {
        r=flag-1;
     for(l=0;l<r;l++)
         {
           q=nums[l];
           nums[l]=nums[r];
           nums[r]=q;
           r--;
         }             //前半倒置
         r=numsSize-1;
     for(l=flag;l<r;l++)
         {
           q=nums[l];
           nums[l]=nums[r];
           nums[r]=q;
           r--;
         }            //后半倒置
         r=numsSize-1;
     for(l=0;l<r;l++)
        {
         q=nums[l];
           nums[l]=nums[r];
           nums[r]=q;
           r--;
        }            //全部倒置
    }
}

4.错题反思 

4.1--数组形式的整数加法 

. - 力扣（LeetCode） 

 原思路：

1.将number数组元素依次取出得到sum

2.sum与k相加；

3.将sum依次传入数组

总结

1.如果数组中数字太多，甚至无法用long long类型存储sum；

最终会溢出

新思路：

取指针指向末尾元素与k的个位相加，成为新的末尾元素；

若超出10；则存储两者之和-10；并存储1至下一次求和

k=k/10；指针前移；

（思路差不多，但代码能力太差最后没写来（可恶））

下面为官方答案

int* addToArrayForm(int* num, int numSize, int k, int* returnSize) {
    int* r=malloc(sizeof(int)*fmax(5,numSize+1));//一直在想如何在不知初始元素个数的情况下建立数组，现在才想到可以用malloc
    int sum=0;
    int tmp;
    * returnSize=0;
     for(int i=numSize-1;i>=0;i--)
     {
       sum=num[i]+k%10;
       k=k/10;
                                                
       if(sum>=10)
       {
        k++;       //若sum>=10，可以直接k++（没想到，单独用i存储了1，不方便）
        r[(* returnSize)++]=sum-10;            //确定新的数组元素
       }

       else
       r[(* returnSize)++]=sum;               //确定新的数组元素
     }

       for(k;k!=0;k=k/10)
        r[(* returnSize)++]=k%10;            //如果k长度大于数组长度

        int n=(* returnSize)-1;

    for(int j=0;j<=((* returnSize)-1)/2;j++)
    {                                       //不一定要先把* returnSize算出来再建立数组，只需最后得到* returnSizeze即可，r的其余空间存不存数据无所谓，只需确定r[* returnSizeze-1]---r[0]之间为所求
      tmp=r[j];
      r[j]=r[n];
      r[n]=tmp;
      n--;
    }
    return r;
}

 

道阻且长，慢慢努力吧。