顺序表|消失的数字|轮转数组|移除元素|合并有序数组|删除有序数组中重复项(C)

面试题 17.04. 消失的数字

---

思路一

排序+遍历
如果下一个不等于上一个数+1，这个下一个数就是消失的数字
时间复杂度$O(N\cdot {\log }_{2}N)$

思路二

0+N等差数列公式计算结果 - 数组中的值，结果就是消失的数字

int missingNumber(int* nums, int numsSize){
    int N = numsSize;
    int ret = N*(N + 1) / 2;
    for (int i = 0; i < N; i++)
    {
        ret -= nums[i];
    }

    return ret;
}

思路三

通过异或解决问题
按位异或，相异为1，相同为0

int missingNumber(int* nums, int numsSize){
    int N = numsSize;
    int x = 0;
    for (int i = 0; i <= N; ++i)
    {
        x ^= i;
    }

    for (int i = 0; i < N; ++i)
    {
        x ^= nums[i];
    }

    return x;
}

0-N有n+1个值，数组中的值比n+1个值少一个

189. 轮转数组

---

• 要求时间复杂度$O(N)$，空间复杂度$O(1)$

方法一

依次挪动，每次挪动一个，挪动k次

k很大时，右旋K%=N次
时间复杂度：$O(N^2)$
空间复杂度：$O(1)$

方法二

用空间换时间
开一个额外的数组，把原数组的后k个拷贝到临时数组的前面，前面剩余的拷贝到后面
最后再拷贝回原数组
时间复杂度$O(N)$
空间复杂度$O(N)$

void rotate(int* nums, int numsSize, int k) {
    int* tmp = (int*)malloc(sizeof(int)*numsSize);
    int n = numsSize;
    k %= n;

    memcpy(tmp, nums+n-k, sizeof(int)*k);
    memcpy(tmp+k, nums, sizeof(int)*(n-k));

    memcpy(nums, tmp, sizeof(int)*n);

    free(tmp);
}

• 先拷贝后k个到tmp数组
• 再拷贝前n-k个到tmp数组后面
• 再将tmp数组整体拷贝到原nums数组

方法三

把前n-k个逆置，把后k个逆置，再整体逆置
时间复杂度$O(N)$
空间复杂度$O(1)$

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 %= numsSize;

    reverse(nums, 0, numsSize - k - 1);
    reverse(nums, numsSize - k, numsSize - 1);
    reverse(nums, 0, numsSize - 1);
}

• 先逆置前n-k个
• 再逆置后k个
• 最后整体逆置

27. 移除元素

---

方法一

用src指向原数组的首元素
开一个大小相同的新数组叫tmp，指针为dst
把src位置不等于val的值插入到dst位置的数据
再把tmp数组拷贝回去
时间复杂度$O(N)$
空间复杂度$O(N)$

可以做到不需要tmp数组

src和dst一起走，还没有遇到val，src赋给dst就是自己赋给自己

dst遇到val，停下来，src继续走，src和dst拉开距离

src找后面不是val的值，依次尾插给dst覆盖

把3覆盖给dst

src不等于val

把0覆盖给dst

src不等于val

把4覆盖给dst

继续遍历

int removeElement(int* nums, int numsSize, int val) {
    int src = 0, dst = 0;
    while (src < numsSize)
    {
	    //不等于val，覆盖尾插到dst位置，++src，++dst
	    //等于val,++src相当于删除
        if (nums[src] != val)
        {
            nums[dst++] = nums[src++];
        }
        else
        {
            src++;
        }
    }
    return dst;
}

88. 合并两个有序数组

---

依次比较，取小的，尾插到新数组
保证数组是非递减排序
nums1的大小包含nums2，把nums2归并到nums1里

倒着比较，取大的依次到着插入

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
    int end1 = m - 1, end2 = n - 1, end = m + n - 1;
    while (end1 >= 0 && end2 >= 0)
    {
        if (nums1[end1] > nums2[end2])
        {
            nums1[end--] = nums1[end1--];
        }
        else
        {
            nums1[end--] = nums2[end2--];
        }
    }
    
    while (end2 >= 0)
    {
        nums1[end--] = nums2[end2--];
    }
}

end1和end2往前遍历，取大的尾插到end

5>3

3>2

2=2，取end2尾插

end2<0，循环结束
当end2遍历完毕后，end1如果有剩余，就不需要变动了
如果end1遍历完，end2还没有，就需要将end2依次尾插到end

26. 删除有序数组中的重复项

---

如果src位置的值等于dst，就src++，相当于删除重复的值
如果src位置的值不等于dst，先++dst，再把src的值赋给dst，最后让src++

src的值等于dst，src++

这时src的值不等于dst
dst++

src的值赋给dst

++src

继续遍历

src与dst不相等
dst++

src赋给dst

src++

…

int removeDuplicates(int* nums, int numsSize) {
    int dst = 0;
    int src = 1;
    while (src < numsSize)
    {
        if (nums[src] == nums[dst])
        {
            src++;
        }
        else
        {
            dst++;
            nums[dst] = nums[src];
            src++;
        }
    }
    return dst + 1;
}

dst是最后一个元素的下标
+1才是长度