題目:

給定兩個陣列，編寫一個函式來計算它們的交集。

示例 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 的元素儲存在磁碟上，磁碟記憶體是有限的，並且你不能一次載入所有的元素到記憶體中，你該怎麼辦？

分析：

注意：集合不需要考慮索引，只需要考慮元素。只要A中的元素，B中有，則相同的元素即是交集（PS:一開始以為陣列的集合需要考慮索引，尷尬啊，高中知識都忘記了）。
首先，我們可以給2個數組進行排序，然後用兩個索引分別代表兩個陣列的起始位置，如果兩個索引所代表的數字相等，則將數字存入結果中，兩個索引均自增1，如果第一個索引所代表的數字大，則第二個索引自增1，反之亦然。

程式碼(PS:有點糙)

/**
 * 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) {
    int *retBuf,*maxBuf,*minBuf,i = 0, j = 0,temp = 0,maxSize=0,minSize = 0;
    retBuf = (int*)malloc((nums1Size>nums2Size?nums2Size:nums1Size)*sizeof(int));
    for(i = 0; i< nums1Size; i++)
    {
        for(
 
j = 0; j < nums1Size-1; j++)
        {
            if(nums1[j] > nums1[j+1])
            {
                temp = nums1[j];
                nums1[j] = nums1[j+1];
                nums1[j+1] = temp;
            }
        }
    }
    
    for(i = 0; i< nums2Size; i++)
    {
        for(j = 0; j < nums2Size-1; j++)
        {
            if(nums2[j] > nums2[j+1])
            {
                temp = nums2[j];
                nums2[j] = nums2[j+1];
                nums2[j+1] = temp;
            }
        }
    }
    
        
    if(nums1Size >= nums2Size)
    {
        maxBuf = nums1;
        minBuf = nums2;
        maxSize = nums1Size;
        minSize = nums2Size;
    }
    else
    {
        maxBuf = nums2;
        minBuf = nums1;
        maxSize = nums2Size;
        minSize = nums1Size;
    }
    i = 0;
    j = 0;
    while((i<minSize)&&(j<maxSize))
    {
        if(minBuf[i] == maxBuf[j])
        {
            retBuf[(*returnSize)++] = maxBuf[j];
            i++;
            j++;
        }
        else if(minBuf[i] > maxBuf[j])
        {
            j++;
        }
        else if(minBuf[i] < maxBuf[j])
        {
            i++;
        }
            
    }
    

    
    return retBuf;
}