leetcode 220. 存在重复元素 III （C语言

给定一个整数数组，判断数组中是否有两个不同的索引 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值最大为 t，并且 i 和 j 之间的差的绝对值最大为 ķ。
示例 1:
输入: nums = [1,2,3,1], k = 3, t = 0
输出: true
示例 2:
输入: nums = [1,0,1,1], k = 1, t = 2
输出: true
示例 3:
输入: nums = [1,5,9,1,5,9], k = 2, t = 3
输出: false

一开始我知道这道题在leetcode上竟然是中等难度的题，觉得不可思议，因为明明思路非常简单，只需要两个循环，一个判断就可以了，于是我写成了这样

bool containsNearbyAlmostDuplicate(int* nums, int numsSize, int k, int t) 
{
    int i,j;
    for(i=0;i<numsSize-1;i++)
    {
        for(j=i+1;j<numsSize;j++)
        {     
             if(abs(nums[i]-nums[j])<=t&&abs(j-i)<=k)
                return 1;
        }
    }
    return 0;
}

然后这个代码没通过，因为
[2147483647,-2147483647]
1
2147483647
这个例子没通过，因为nums[i]-nums[j]超过了长整型的范围，于是就计算错了。于是我把代码改成了这样

bool containsNearbyAlmostDuplicate(int* nums, int numsSize, int k, int t) 
{
    int i,j;
    long long int a,b;
    for(i=0;i<numsSize-1;i++)
    {
        for(j=i+1;j<numsSize;j++)
        {     
		     a=nums[i];
		     b=nums[j];
             if(abs(a-b)<=t&&abs(j-i)<=k)
                return 1;
        }
    }
    return 0;
}

这个例子还是没有过，一直没找到问题，后面想是不是abs这个函数有问题，然后试了下这个代码；

bool containsNearbyAlmostDuplicate(int* nums, int numsSize, int k, int t) 
{
    int i,j;
    long long int a;
    for(i=0;i<numsSize-1;i++)
    {
        for(j=i+1;j<numsSize;j++)
        {     
		     a=nums[i]-nums[j];
             if(a<=t&&abs(j-i)<=k)
                return 1;
        }
    }
    return 0;
}

还是错的，后面找到问题是因为nums[i]-nums[j]先进行计算，然后再赋值，赋值的时候已经不对了，他是先将两数相减存储为整形，再将整形赋值给长整型，所以错了，于是我改成了下面这种。

bool containsNearbyAlmostDuplicate(int* nums, int numsSize, int k, int t) 
{
    int i,j;
    long long int a,b;
    for(i=0;i<numsSize-1;i++)
    {
        for(j=i+1;j<numsSize;j++)
        {     
		     a=nums[i];
		     b=nums[j];
		     a=a-b;
		     if(a<0)
			     a=-a;
             if(a<=t&&abs(j-i)<=k)
                return 1;
        }
    }
    return 0;
}

然后就成功了，不过还是没有搞懂abs函数的问题，可能和nums[i]-nums[j]的机制一样，或许这是C语言的一个小瑕疵吧。还真不能小看中等的题。

C语言执行为60ms的代码（别人的

void QuickSort(int* nums, int *pos, int start, int end)
{
    if(start>=end)return;
    int i = start, j = end, temp1 = nums[start], temp2 = pos[start];
    while(i<j)
    {
        while(nums[j]>=temp1 && i<j) j--;
        nums[i] = nums[j]; pos[i] = pos[j];
        while(nums[i]<=temp1 && i<j) i++;
        nums[j] = nums[i]; pos[j] = pos[i];
    }
    nums[i] = temp1; pos[i] = temp2;
    QuickSort(nums, pos, start, i-1);
    QuickSort(nums, pos, i+1, end);
    return;
}

bool containsNearbyAlmostDuplicate(int* nums, int numsSize, int k, int t) {
    int *pos = malloc(sizeof(int) * numsSize) ;
    long *num = malloc(sizeof(long) * numsSize) ;
    for(int i = 0; i <numsSize; i++) pos[i] = i;
    QuickSort(nums, pos, 0, numsSize - 1);
    for(int i = 0; i <numsSize; i++) num[i] = (long)nums[i];
    
    for(int i = 0; i <numsSize; i++)
        for(int j = i + 1; j <numsSize; j++)
        {
            if(num[j] - num[i] <= (long)t)
            {
                if(pos[i] - pos[j] <= k && pos[i] - pos[j] >= -k) return 1;
            }
            else break;
        }
    
    return 0;
}