[제안을 가리키는 검|5. 정렬된 배열에서 숫자 I를 찾습니다]

0. 정렬된 배열에서 숫자 I 찾기

1. 비효율적인 방법©

• 이진 검색을 통해 목표 값을 찾습니다. 현지 시간 복잡도는 O(logN)입니다. 그런 다음 찾을 숫자가 길이 N의 배열에 나타날 수 있으므로 처음 3개와 마지막 3개를 각각 스캔할 때까지 목표 값 주위를 스캔합니다. N번이므로 현지 시간 복잡도는 O(N)입니다.

• 전체적인 시간복잡도는 O(N)으로 매우 비효율적이며, 여러 숫자를 직접 탐색하고 스캔하는 어리석은 방법인 O(N)과 동일한 시간복잡도를 가지므로 바람직하지 않습니다.

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

int search(int* nums, int numsSize, int target) {
    
    
    int count = 0;
    int index = BinarySearch(nums, numsSize, target);
    if (index == -1)
    {
    
    
        return count;
    }
    else
    {
    
    
        count++;
    }
        int left=index-1,right=index+1;
        while (left >= 0&&nums[left] == target)
        {
    
    
            count++;
            left--;    
        }
        while (right < numsSize&&nums[right] == target)
        {
    
    
            count++;
            right++;
        }

    return count;
}

2.바이너리 검색©

이진 탐색을 어떻게 하면 더 잘 활용할 수 있을지 고민해 본다.이전 알고리즘에서는 첫 번째 목표와 마지막 목표를 찾기 위해 하나씩 목표를 찾는 데 주로 시간이 소요되기 때문에 어떤 방법을 사용하면 직접적이고 더 빠르게 첫 번째 목표를 찾을 수 있을까 ? 그리고 마지막 목표 .

• 이진 검색 알고리즘은 항상 배열의 중앙에 있는 숫자를 대상과 비교합니다. 가운데에 있는 숫자가 대상보다 크면 전반부에 대상이 나타날 수 있습니다. 다음 라운드에서는 다음 라운드에서만 검색하면 됩니다. 중간에 있는 숫자가 목표보다 크면 전반에 목표가 나타날 수 있고, 목표보다 작으면 후반에 목표가 나타날 수 있습니다. 다음 라운드에서는 우리만 후반에 찾아봐야지.

• 가운데 숫자가 목표값과 같으면 어떻게 되나요? 먼저 이 숫자가 첫 번째 목표인지 확인합니다. 이 숫자의 이전 숫자가 목표와 같지 않으면 이 숫자가 첫 번째 목표가 되고, 이 숫자의 이전 숫자가 목표와 같으면 첫 번째 목표가 됩니다. 전반전에서는 다음 라운드를 위해 전반전에서만 검색하면 됩니다.

• 시간 복잡도: O(logN)

int GetFirstOfK(int* nums, int numsSize, int target)
{
    int left = 0, right = numsSize - 1;
    while (left <= right)
    {
        int mid = left + (right - left) / 2;
        if (nums[mid] > target)
        {
            right = mid - 1;
        }
        else if (nums[mid] < target)
        {
            left = mid + 1;
        }
        else
        {
            if (mid-1>=0&&nums[mid - 1] != target || mid==0)//关键边界处理
            {
                return mid;
            }
            else
            {
                right = mid - 1;
            }
        }
    }
    return -1;
}

int GetLastOfK(int* nums, int numsSize, int target)
{
    int left = 0, right = numsSize - 1;
    while (left <= right)
    {
        int mid = left + (right - left) / 2;
        if (nums[mid] > target)
        {
            right = mid - 1;
        }
        else if (nums[mid] < target)
        {
            left = mid + 1;
        }
        else
        {
            if (mid + 1 <numsSize && nums[mid + 1] != target||mid==numsSize-1)
            {
                return mid;
            }
            else
            {
                left = mid + 1;
            }
        }
    }
    return -1;
}

int search(int* nums, int numsSize, int target) {
    int count = 0;
    int first = GetFirstOfK(nums, numsSize, target);
    int last = GetLastOfK(nums, numsSize, target);
    if (first != -1 && last != -1)
    {
        return last - first + 1;
    }
    return count;
}