leetcode初级数组之两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
说明：
输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
进阶:
如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

#include <stdlib.h>
void quicksort(int* nums, int left, int right);
void copy(int* nums1, int* nums2, int k);
//先递增排序，这样可以利用顺序来过滤掉已经不可能出现交集的元素，再定义两个脚标变量i,j，
//这两个变量都从0开始，向后遍历，如果两个数组的值相同，存下这个值，两个脚标同时加1；
//如果两个数组的值不同，那么值较小的数组脚标值加1，另一个脚标值等待直到遍历完短的那个数组
/**
* Return an array of size *returnSize.
* Note: The returned array must be malloced, assume caller calls free().
*/
int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    quicksort(nums1, 0, nums1Size-1);
    quicksort(nums2, 0, nums2Size-1);

    int len = (nums2Size > nums1Size) ? nums1Size : nums2Size;
    int* res = (int*)malloc(sizeof(int)* len);

    int i = 0, j = 0, k = 0;
    while ((i < nums1Size) && (j < nums2Size))
    {
        if (nums2[j] == nums1[i])
        {
            res[k++] = nums2[j];
            i++;
            j++;
        }
        else if (nums2[j] < nums1[i])
            j++;
        else
            i++;
    }
    *returnSize = k;
    int* ret = (int*)malloc(sizeof(int)* k);

    copy(ret, res, k);
    free(res);
    return ret;
}
void copy(int* nums1, int* nums2, int k)
{
    while (k--)
        *nums1++ = *nums2++;
}
void quicksort(int* nums, int left, int right)
{
    if (left > right) return;
    int base = nums[left];
    int i = left, j = right, tmp;
    while (i != j)
    {
        while ((nums[j] >= base) && (i<j))
            j--;
        while ((nums[i] <= base) && (i<j))
            i++;
        if (i<j)
        {
            tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    }
    nums[left] = nums[i];
    nums[i] = base;

    quicksort(nums, left, i - 1);
    quicksort(nums, i + 1, right);
}