n 균일하게 분포된 값의 정렬된 배열이 주어지면 arr[] 배열에서 특정 요소 x를 검색하는 함수를 작성합니다.
선형 검색은 O(n) 시간에 요소를 찾습니다. 점프 검색 O(n) 시간이 걸리고 이진 검색 O(log n) 시간이 걸립니다.
보간 검색은 다음보다 개선되었습니다. 이진 검색 예를 들어 정렬된 배열의 값이 균일하게 분포되는 경우입니다. 보간은 알려진 데이터 포인트의 개별 집합 범위 내에서 새로운 데이터 포인트를 구성합니다. 이진 검색은 항상 중간 요소로 이동하여 확인합니다. 반면에 보간 검색은 검색되는 키 값에 따라 다른 위치로 이동할 수 있습니다. 예를 들어 키 값이 마지막 요소에 가까울 경우 보간 검색은 끝 쪽으로 검색을 시작할 가능성이 높습니다.
검색할 위치를 찾으려면 다음 공식을 사용합니다.
// 수식의 아이디어는 pos의 더 높은 값을 반환하는 것입니다.
// 검색할 요소가 arr[hi]에 가까울 때. 그리고
// arr[lo]에 가까울수록 더 작은 값
arr[] ==> 요소를 검색해야 하는 배열
x ==> 검색할 요소
스프링 부트lo ==> arr[]의 시작 인덱스
이진 검색을 위한 Python 프로그램안녕하세요 ==> arr[]의 끝 색인
이후 = +
다양한 보간 방법이 있으며 그 중 하나가 선형 보간이라고 알려져 있습니다. 선형 보간은 (x1y1)과 (x2y2)로 가정하는 두 개의 데이터 포인트를 사용하며 공식은 다음과 같습니다. at point(xy).
이 알고리즘은 사전에서 단어를 검색하는 방식으로 작동합니다. 보간 검색 알고리즘은 이진 검색 알고리즘을 개선합니다. 값을 찾는 공식은 다음과 같습니다. K = >K는 검색 공간을 좁히는 데 사용되는 상수입니다. 이진 검색의 경우 이 상수의 값은 K=(낮음+높음)/2입니다.
자바 부울 문자열
pos의 공식은 다음과 같이 유도될 수 있다.
Let's assume that the elements of the array are linearly distributed.
General equation of line : y = m*x + c.
y is the value in the array and x is its index.
Now putting value of lohi and x in the equation
arr[hi] = m*hi+c ----(1)
arr[lo] = m*lo+c ----(2)
x = m*pos + c ----(3)
m = (arr[hi] - arr[lo] )/ (hi - lo)
subtracting eqxn (2) from (3)
x - arr[lo] = m * (pos - lo)
lo + (x - arr[lo])/m = pos
pos = lo + (x - arr[lo]) *(hi - lo)/(arr[hi] - arr[lo])
연산
보간 알고리즘의 나머지 부분은 위의 파티션 논리를 제외하고 동일합니다.
- 1단계: 루프에서 프로브 위치 공식을 사용하여 'pos' 값을 계산합니다.
- 2단계: 일치하는 경우 항목의 색인을 반환하고 종료합니다.
- 3단계: 항목이 arr[pos]보다 작으면 왼쪽 하위 배열의 프로브 위치를 계산합니다. 그렇지 않으면 오른쪽 하위 배열에서 동일하게 계산합니다.
- 4단계: 일치하는 항목이 발견되거나 하위 배열이 0으로 줄어들 때까지 반복합니다.
아래는 알고리즘의 구현입니다.
// C++ program to implement interpolation // search with recursion #include
// C program to implement interpolation search // with recursion #include
// Java program to implement interpolation // search with recursion import java.util.*; class GFG { // If x is present in arr[0..n-1] then returns // index of it else returns -1. public static int interpolationSearch(int arr[] int lo int hi int x) { int pos; // Since array is sorted an element // present in array must be in range // defined by corner if (lo <= hi && x >= arr[lo] && x <= arr[hi]) { // Probing the position with keeping // uniform distribution in mind. pos = lo + (((hi - lo) / (arr[hi] - arr[lo])) * (x - arr[lo])); // Condition of target found if (arr[pos] == x) return pos; // If x is larger x is in right sub array if (arr[pos] < x) return interpolationSearch(arr pos + 1 hi x); // If x is smaller x is in left sub array if (arr[pos] > x) return interpolationSearch(arr lo pos - 1 x); } return -1; } // Driver Code public static void main(String[] args) { // Array of items on which search will // be conducted. int arr[] = { 10 12 13 16 18 19 20 21 22 23 24 33 35 42 47 }; int n = arr.length; // Element to be searched int x = 18; int index = interpolationSearch(arr 0 n - 1 x); // If element was found if (index != -1) System.out.println('Element found at index ' + index); else System.out.println('Element not found.'); } } // This code is contributed by equbalzeeshan
# Python3 program to implement # interpolation search # with recursion # If x is present in arr[0..n-1] then # returns index of it else returns -1. def interpolationSearch(arr lo hi x): # Since array is sorted an element present # in array must be in range defined by corner if (lo <= hi and x >= arr[lo] and x <= arr[hi]): # Probing the position with keeping # uniform distribution in mind. pos = lo + ((hi - lo) // (arr[hi] - arr[lo]) * (x - arr[lo])) # Condition of target found if arr[pos] == x: return pos # If x is larger x is in right subarray if arr[pos] < x: return interpolationSearch(arr pos + 1 hi x) # If x is smaller x is in left subarray if arr[pos] > x: return interpolationSearch(arr lo pos - 1 x) return -1 # Driver code # Array of items in which # search will be conducted arr = [10 12 13 16 18 19 20 21 22 23 24 33 35 42 47] n = len(arr) # Element to be searched x = 18 index = interpolationSearch(arr 0 n - 1 x) if index != -1: print('Element found at index' index) else: print('Element not found') # This code is contributed by Hardik Jain
// C# program to implement // interpolation search using System; class GFG{ // If x is present in // arr[0..n-1] then // returns index of it // else returns -1. static int interpolationSearch(int []arr int lo int hi int x) { int pos; // Since array is sorted an element // present in array must be in range // defined by corner if (lo <= hi && x >= arr[lo] && x <= arr[hi]) { // Probing the position // with keeping uniform // distribution in mind. pos = lo + (((hi - lo) / (arr[hi] - arr[lo])) * (x - arr[lo])); // Condition of // target found if(arr[pos] == x) return pos; // If x is larger x is in right sub array if(arr[pos] < x) return interpolationSearch(arr pos + 1 hi x); // If x is smaller x is in left sub array if(arr[pos] > x) return interpolationSearch(arr lo pos - 1 x); } return -1; } // Driver Code public static void Main() { // Array of items on which search will // be conducted. int []arr = new int[]{ 10 12 13 16 18 19 20 21 22 23 24 33 35 42 47 }; // Element to be searched int x = 18; int n = arr.Length; int index = interpolationSearch(arr 0 n - 1 x); // If element was found if (index != -1) Console.WriteLine('Element found at index ' + index); else Console.WriteLine('Element not found.'); } } // This code is contributed by equbalzeeshan
<script> // Javascript program to implement Interpolation Search // If x is present in arr[0..n-1] then returns // index of it else returns -1. function interpolationSearch(arr lo hi x){ let pos; // Since array is sorted an element present // in array must be in range defined by corner if (lo <= hi && x >= arr[lo] && x <= arr[hi]) { // Probing the position with keeping // uniform distribution in mind. pos = lo + Math.floor(((hi - lo) / (arr[hi] - arr[lo])) * (x - arr[lo]));; // Condition of target found if (arr[pos] == x){ return pos; } // If x is larger x is in right sub array if (arr[pos] < x){ return interpolationSearch(arr pos + 1 hi x); } // If x is smaller x is in left sub array if (arr[pos] > x){ return interpolationSearch(arr lo pos - 1 x); } } return -1; } // Driver Code let arr = [10 12 13 16 18 19 20 21 22 23 24 33 35 42 47]; let n = arr.length; // Element to be searched let x = 18 let index = interpolationSearch(arr 0 n - 1 x); // If element was found if (index != -1){ document.write(`Element found at index ${index}`) }else{ document.write('Element not found'); } // This code is contributed by _saurabh_jaiswal </script>
// PHP program to implement $erpolation search // with recursion // If x is present in arr[0..n-1] then returns // index of it else returns -1. function interpolationSearch($arr $lo $hi $x) { // Since array is sorted an element present // in array must be in range defined by corner if ($lo <= $hi && $x >= $arr[$lo] && $x <= $arr[$hi]) { // Probing the position with keeping // uniform distribution in mind. $pos = (int)($lo + (((double)($hi - $lo) / ($arr[$hi] - $arr[$lo])) * ($x - $arr[$lo]))); // Condition of target found if ($arr[$pos] == $x) return $pos; // If x is larger x is in right sub array if ($arr[$pos] < $x) return interpolationSearch($arr $pos + 1 $hi $x); // If x is smaller x is in left sub array if ($arr[$pos] > $x) return interpolationSearch($arr $lo $pos - 1 $x); } return -1; } // Driver Code // Array of items on which search will // be conducted. $arr = array(10 12 13 16 18 19 20 21 22 23 24 33 35 42 47); $n = sizeof($arr); $x = 47; // Element to be searched $index = interpolationSearch($arr 0 $n - 1 $x); // If element was found if ($index != -1) echo 'Element found at index '.$index; else echo 'Element not found.'; return 0; #This code is contributed by Susobhan Akhuli ?> 산출
Element found at index 4
시간 복잡도: 오(로그2(통나무2n)) 평균적인 경우, O(n)은 최악의 경우
보조 공간 복잡성: 오(1)
경찰 부국장
또 다른 접근 방식:-
이것이 보간 검색의 반복 접근 방식입니다.
- 1단계: 루프에서 프로브 위치 공식을 사용하여 'pos' 값을 계산합니다.
- 2단계: 일치하는 경우 항목의 색인을 반환하고 종료합니다.
- 3단계: 항목이 arr[pos]보다 작으면 왼쪽 하위 배열의 프로브 위치를 계산합니다. 그렇지 않으면 오른쪽 하위 배열에서 동일하게 계산합니다.
- 4단계: 일치하는 항목이 발견되거나 하위 배열이 0으로 줄어들 때까지 반복합니다.
아래는 알고리즘의 구현입니다.
C++// C++ program to implement interpolation search by using iteration approach #include
// Java program to implement interpolation // search with recursion import java.util.*; class GFG { // If x is present in arr[0..n-1] then returns // index of it else returns -1. public static int interpolationSearch(int arr[] int lo int hi int x) { int pos; if (lo <= hi && x >= arr[lo] && x <= arr[hi]) { // Probing the position with keeping // uniform distribution in mind. pos = lo + (((hi - lo) / (arr[hi] - arr[lo])) * (x - arr[lo])); // Condition of target found if (arr[pos] == x) return pos; // If x is larger x is in right sub array if (arr[pos] < x) return interpolationSearch(arr pos + 1 hi x); // If x is smaller x is in left sub array if (arr[pos] > x) return interpolationSearch(arr lo pos - 1 x); } return -1; } // Driver Code public static void main(String[] args) { // Array of items on which search will // be conducted. int arr[] = { 10 12 13 16 18 19 20 21 22 23 24 33 35 42 47 }; int n = arr.length; // Element to be searched int x = 18; int index = interpolationSearch(arr 0 n - 1 x); // If element was found if (index != -1) System.out.println('Element found at index ' + index); else System.out.println('Element not found.'); } }
# Python equivalent of above C++ code # Python program to implement interpolation search by using iteration approach def interpolationSearch(arr n x): # Find indexes of two corners low = 0 high = (n - 1) # Since array is sorted an element present # in array must be in range defined by corner while low <= high and x >= arr[low] and x <= arr[high]: if low == high: if arr[low] == x: return low; return -1; # Probing the position with keeping # uniform distribution in mind. pos = int(low + (((float(high - low)/( arr[high] - arr[low])) * (x - arr[low])))) # Condition of target found if arr[pos] == x: return pos # If x is larger x is in upper part if arr[pos] < x: low = pos + 1; # If x is smaller x is in lower part else: high = pos - 1; return -1 # Main function if __name__ == '__main__': # Array of items on whighch search will # be conducted. arr = [10 12 13 16 18 19 20 21 22 23 24 33 35 42 47] n = len(arr) x = 18 # Element to be searched index = interpolationSearch(arr n x) # If element was found if index != -1: print ('Element found at index'index) else: print ('Element not found')
// C# program to implement interpolation search by using // iteration approach using System; class Program { // Interpolation Search function static int InterpolationSearch(int[] arr int n int x) { int low = 0; int high = n - 1; while (low <= high && x >= arr[low] && x <= arr[high]) { if (low == high) { if (arr[low] == x) return low; return -1; } int pos = low + (int)(((float)(high - low) / (arr[high] - arr[low])) * (x - arr[low])); if (arr[pos] == x) return pos; if (arr[pos] < x) low = pos + 1; else high = pos - 1; } return -1; } // Main function static void Main(string[] args) { int[] arr = {10 12 13 16 18 19 20 21 22 23 24 33 35 42 47}; int n = arr.Length; int x = 18; int index = InterpolationSearch(arr n x); if (index != -1) Console.WriteLine('Element found at index ' + index); else Console.WriteLine('Element not found'); } } // This code is contributed by Susobhan Akhuli
// JavaScript program to implement interpolation search by using iteration approach function interpolationSearch(arr n x) { // Find indexes of two corners let low = 0; let high = n - 1; // Since array is sorted an element present // in array must be in range defined by corner while (low <= high && x >= arr[low] && x <= arr[high]) { if (low == high) { if (arr[low] == x) { return low; } return -1; } // Probing the position with keeping // uniform distribution in mind. let pos = Math.floor(low + (((high - low) / (arr[high] - arr[low])) * (x - arr[low]))); // Condition of target found if (arr[pos] == x) { return pos; } // If x is larger x is in upper part if (arr[pos] < x) { low = pos + 1; } // If x is smaller x is in lower part else { high = pos - 1; } } return -1; } // Main function let arr = [10 12 13 16 18 19 20 21 22 23 24 33 35 42 47]; let n = arr.length; let x = 18; // Element to be searched let index = interpolationSearch(arr n x); // If element was found if (index != -1) { console.log('Element found at index' index); } else { console.log('Element not found'); }
산출
Element found at index 4
시간 복잡도: 평균적인 경우 O(log2(log2 n)), 최악의 경우 O(n)
보조 공간 복잡성: 오(1)