一，知识点

1，指针定义

在数据在内存中的存放以字节为单位，为了正确使用这些数据，会把内存中每个字节编号，即为地址。

指针即为地址，可以定义一个指针变量来存放地址：（类型）*（指针变量名）。之后可以通过指针来直接访问变量从而实现改变变量的作用。

2，指针使用

定义完后可以对指针赋值。可以使用&（变量名）来得到所要变量的地址，放入指针变量中。之后对指针变量进行解引用*操作即可。

二，习题

1，1470. 重新排列数组 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* shuffle(int* nums, int numsSize, int n, int* returnSize)
{
     int i=1;
     int j=numsSize;
     for(i=1,j=n;i<numsSize;i+=2,j++)
     {
        int tmp=*(nums+j);
        int k=j-1;
        for(;k>=i;k--)
        {
            *(nums+k+1)=*(nums+k);
        }
        nums[i]=tmp;
     }
     *returnSize=numsSize;
     return nums;
}

?思路：第一位是不动的，所以让i从1开始，1的时候放下标为j处的数，就用tmp先把他存起来，然后让他前面所有的数往后挪一位，再将tmp给下标为1处的数，循环直到排序完成。

2，1929. 数组串联 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* getConcatenation(int* nums, int numsSize, int* returnSize)
{
       int* ans=(int*)malloc(sizeof(int)*2*numsSize);
       int i=0;
       for(i=0;i<numsSize;i++)
       {
           *(ans+i)=*(nums+i);
       }
       int j=0;
       for(;i<2*numsSize;i++)
       {
           *(ans+i)=*(nums+j);
           j++;
       }
       *returnSize=2*numsSize;
       return ans;
}

实际上就是录入两边nums数组。?

3，1920. 基于排列构建数组 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* buildArray(int* nums, int numsSize, int* returnSize)
{
     int* ans=(int*)malloc(sizeof(int)*numsSize);
     int i=0;
     for(i=0;i<numsSize;i++)
     {
         *(ans+i)=*(nums+*(nums+i));
     }
     *returnSize=numsSize;
     return ans;
}

按照题目的意思写出来即可过。?

4，1480. 一维数组的动态和 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* runningSum(int* nums, int numsSize, int* returnSize)
{
    int* ans=(int*)malloc(sizeof(int)*numsSize);
     int i=0;
     for(i=0;i<numsSize;i++)
     {
         int sum=0;
         int k=0;
         for(k=0;k<=i;k++)
         {
             sum+=nums[k];
         }
         *(ans+i)=sum;
     }
     *returnSize=numsSize;
     return ans;
}

答案数组里每个元素都等于原数组到这个元素的所有元素相加，再放入答案数组即可?。

5，剑指 Offer 58 - II. 左旋转字符串 - 力扣（LeetCode） (leetcode-cn.com)

char* reverseLeftWords(char* s, int n)
{
    int len=strlen(s);
    char*ans=(char*)malloc(sizeof(char)*(len+1));
    char* stop=&s[n];
    char*start=stop;
    char* left=s;
    int i=0;
    for(;*start!='\0';start++)
    {
        ans[i++]=*(start);
    }
    while(left<stop)
    {
        ans[i++]=*left;
        left++;
    }
    ans[i]='\0';
    return ans;
}

用stop指针来记录要换位的最后一个元素，让后用start与stop相同，让start一直走到原数组最后一个元素并将其放入答案数组中。?然后再让left从原数组第一个开始走到换位的最后一个元素，放入答案数组，即可。最后再放入‘\0’;

6，1108. IP 地址无效化 - 力扣（LeetCode） (leetcode-cn.com)

char * defangIPaddr(char * address)
{
    char*ans=(char*)malloc(sizeof(char)*100);
    int len=strlen(address);
    int i=0;
    int j=0;
    for(i=0;i<=len;i++)
    {
       if(address[i]!='.')
         {
             ans[j]=address[i];
             j++;
         }
         else
         {
             ans[j]='[';
             ans[j+1]='.';
             ans[j+2]=']';
             j+=3;
         }
    }
    return ans;
}

?开一个足够大的数组，然后遍历检测，只要检测到 . 就换掉即可。

7，剑指 Offer 05. 替换空格 - 力扣（LeetCode） (leetcode-cn.com)

char* replaceSpace(char* s)
{
      int len=strlen(s);
      int i=0,j=0;
      char* ret=(char*)malloc(10000*sizeof(char));
      for(i=0,j=0;i<len;i++,j++)
      {
          if(s[i]==' ')
          {
             ret[j]='%';
             ret[j+1]='2';
             ret[j+2]='0';
             j+=2;
          }
          else
          ret[j]=s[i];
      }
      ret[j]='\0';
      return ret;
}

开一个足够大的数组，然后遍历检测，只要检测到 . 就换掉即可。

8，1365. 有多少小于当前数字的数字 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize)
{
    int*ans=(int*)malloc(sizeof(int)*numsSize);
    int i=0;
    for(i=0;i<numsSize;i++)
    {
        int j=0;
        int count=0;
        for(j=0;j<numsSize;j++)
        {
            if(nums[i]>nums[j])
            count++;
        }
        ans[i]=count;
    }
    *returnSize=numsSize;
    return ans;
}

?两次遍历即可解决。一次定位元素，一次寻找比他小的元素的个数。

9，剑指 Offer 17. 打印从1到最大的n位数 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* printNumbers(int n, int* returnSize)
{
    int count=pow(10,n);
     int i=0;
     int* ans=(int*)malloc(sizeof(int)*count);
     for(i=0;i<count-1;i++)
     {
        ans[i]=i+1;
     }
     *returnSize=count-1;
     return ans;
}

?用count存放需要打印的个数，然后一个一个打印即可。

10，1389. 按既定顺序创建目标数组 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 void back(int* arr,int n)
 {
      int i=n;
      int tmp;
      for(i=n;arr[i]!=-1;i++)
            ;
      for(;i>n;i--)
      {
          arr[i]=arr[i-1];
      }
 }
int* createTargetArray(int* nums, int numsSize, int* index, int indexSize, int* returnSize)
{
       *returnSize = numsSize;
       int* target=(int*)malloc(sizeof(int)*(numsSize+2));
       int i=0;
       for(i=0;i<numsSize+2;i++)
       {
           target[i]=-1;
       }
       for(i=0;i<numsSize;i++)
       {
               if(target[index[i]]==-1)
               target[index[i]]=nums[i];
               else
               {
                   back(target,index[i]);
                   target[index[i]]=nums[i];
               }
       }
       return target;
}

?按照题目的意思写，用索引数组里的元素的值为下标，来放入nums数组里的元素，同时检测一下是否在原位置已有元素，如果有就让这个位置上以后的元素集体向后退一位，再插入。循环次过程即可。