二分查找

/*供暖器*/
/*  房屋：[1,2,3]，供暖器：[2]，半径：1
    房屋：[1,2,3,4]，供暖器：[1,4]，半径：1
    房屋：[1,5]，供暖器：[2]，半径：3
*/

#include <stdlib.h>
#include <stdio.h>

/*二分法*/

#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))

int binarySearch(const int *nums,int numsSize,int target)
{
    int left = 0,right = numsSize - 1;
    if(nums[left] > target)
    {
        return -1;
    }

    while (left < right)
    {
        int mid = left + (right - left)/2;
        if (nums[mid] > target)
        {
            right = mid - 1;
        }
        else
        {
            left = mid;
        }
        
    }
    return left;
    
}

int cmp(const void *a,const void *b)
{
    return *(int *)a - *(int *)b;
}

int findRadius(int *house,int houseSize,int *hearters,int hearterSize)
{
    int ans = 0;
    qsort(house,houseSize,sizeof(int),cmp);

    for(int k=0;k<houseSize;k++)
    {
        int i = binarySearch(hearters,hearterSize,house[k]);
        int j = i + 1;
        int leftDistance = i < 0 ? __INT_MAX__ : house[k] - hearters[i];
        int rihgtDistance = j >= hearterSize ? __INT_MAX__ : hearters[j] - house[k];
        int curDistance = MIN(leftDistance,rihgtDistance);
        ans = MAX(ans,curDistance);
    }
    return ans;
}
/*排序+双指针*/
int findRadius2(int *houses,int housesSize,int *heaters,int heatersSize)
{
    int ans = 0;
    qsort(heaters,heatersSize,sizeof(int),cmp);
    qsort(houses,housesSize,sizeof(int),cmp);

    for (int i = 0,j = 0; i < housesSize; i++)
    {
        int curDistance = abs(houses[i] - heaters[j]);
        while (j < heatersSize - 1 && abs(houses[i] - heaters[j]) >= abs(houses[i] - heaters[j+1]))
        {
            j++;
            curDistance = MIN(curDistance,abs(houses[i] - heaters[j]));
        }
        ans = MAX(ans,curDistance);
    }
    return ans;
}

int main(int argc,char *argv[])
{
    int house[2]={1,5};
    int hearters[1]={2};

    int ans = findRadius(house,2,hearters,1);
    printf("ans : %d \n",ans);
    ans = findRadius2(house,2,hearters,1);
    printf("ans : %d \n",ans);
}

 

/*有多少小于当前数字的数字*/
/*  nums[] ={8,1,2,2,3};
    ans[]  ={4,0,1,1,3};

*/
/*  tmp[] = {1,2,2,3,8}
    8  找左边界

    mid = 2
    left = 0 ,right = n-1;
    while(right>left)
    {
        int mid = left+ (right - left)/2;
        if(tmp[mid] > target)
        {
            right = mid;
        }
        else
        {
            left = mid;
        }
    }
*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>



int cmp(const void *a,const void *b)
{
    return (*(int *)a - *(int *)b);
}

int *smallerNumbersThanCurrent(int *nums,int numsSize,int *returnSize)
{
    int *nums_cpy = (int *)malloc(sizeof(int)*numsSize);
    memcpy(nums_cpy,nums,sizeof(int)*numsSize);

    int *result = (int *)malloc(sizeof(int)*numsSize);

    qsort(nums_cpy,numsSize,sizeof(int),cmp);

    for (int i = 0; i < numsSize; i++)
    {
        int target = nums[i];
        int left = 0;
        int right = numsSize - 1;

        while (right-left>=1)
        {
            int mid = left + (right - left)/2;
            if (nums_cpy[mid]<target)
            {
                left = mid + 1;
            }
            else if (nums_cpy[mid]>target)
            {
                right = mid - 1;
            }
            else
            {
                right = mid - 1;
            }
            
        }
        result[i] = left;
        
    }
    printf("result[]: ");
    for (int i = 0; i < numsSize; i++)
    {
        printf(" %d ",result[i]);
    }
    printf("\n");
    *returnSize = numsSize;
    return result;

}

int main(int argc,char *argv[])
{
    int nums[]={8,1,2,2,3};
    int returnSize =0;
    smallerNumbersThanCurrent(nums,sizeof(nums)/sizeof(int),&returnSize);
}