Fibonacci Lookup Method

2. void Fibonacci (int *f)
4. {
6. F[0] = 1;
8. F[1] = 1;
12. For (int i = 2; i < MAXSIZE; i++)
14. {
16. F[i] = F[i-1] + f[i-2];
18. }
20. }
24. int Fibonacci_search (int *a, int n, int key)
26. {
28. int Low, high, mid;
32. low = 1;
34. High = n-1;
38. int k = 0;
40. int f[maxsize];
42. Fibonacci (F);
46. //Question one: This finds the position of N in the Fibonacci sequence, why is f[k]-1, not f[k]?
48. While (n > F[k]-1)
50. {
52. k++;
54. }
58. //Question two:
60. //This place, I found that the length of the array a looked for is not good, for example, I am now looking for 31 in the position of the array a
62. //Then, because n = 13, is located between the 7th number (21) and 8th number (34) in the Fibonacci sequence, so K's
64. //value is 7,f[k]-1 equals 20, then the length of array a needs to be a[20]. Change the number again, I don't know this
66. //How should I control it?
68. For (int i = n; i < f[k]-1; i++)
70. {
72. A[i] = A[high];
74. }
78. //Question three:
80. //And this judgment, when the key value is less than a[mid], in [Low, f[k-1]-1] in the range of search
82. //When the key value is greater than a[mid], search within the range of [f[k-2]-1], what is the basis?
84. While (Low <= high)
86. {
88. MID = low + f[k-1]-1;
92. if (Key < A[mid])
94. {
96. High = mid-1;
98. K = k-1;
100. }
102. Else if (key > A[mid])
104. {
106. Low = mid + 1;
108. K = k-2;
110. }
112. Else
114. {
116. if (mid <= High)
118. {
120. return mid;
122. }
124. Else
126. return n;
128. }
130. }
132. return-1;
134. }
140. Analytical:
142. The first thing to be clear: if the number of elements of an ordered table is n, and N is exactly (some Fibonacci number-1), i.e., n=f[k]-1, the Fibonacci lookup method can be used. If the element n of an ordered table is not equal to (some Fibonacci number-1), i.e. n≠f[k]-1, then the element of the ordered table must be extended to the Fibonacci number of 1 that is greater than N, this code:
144. for (int i = n; i < f[k]-1; i++)
146. {
148. A[i] = A[high];
150. }
152. Is this role.
156. Answer below
158. The first question: Read the above and you should know why ① is. Find the position of N in the Fibonacci sequence, why F[k]-1, not f[k], because the Fibonacci lookup method is determined by f[k]-1, not f[k]. If you don't understand for a moment, keep looking.
162. The second question: the length of a is actually very good estimates, such as you define a 10 elements of the ordered array a[20],n=10, then N is located in 8 and 13, that is, f[6] and f[7], so k=7, at this time the number of elements of the array A is expanded to: f[7] 1 = 12; As you define a b[20], and B has 12 elements, that is, n=12, then very good, n = f[7]-1 = 12, do not need to expand, or n=8 or 9 or 11, it will be expanded to 12, and then as you cite the example, n=13, and finally arrive at N at 13 and 21, that is f[7] and F[8], at this time k=8, then f[8]-1 = 20, array A will have 20 elements. So, n = x (13<=x& lt;=20), the last is to be expanded to 20, if n=25, then the number of elements of array A must be expanded to 34-1 = 33 (25 bits 21 and 34, that is f[8] and f[9), at this time k=9,f[9]- 1 = 33), so when n = x (21<=x<=33), the last is expanded to 33. That is to say, the number of elements in the last array must be (some Fibonacci number-1), which is the beginning of the relationship between N and F[k]-1.
166. The third problem: for binary lookups, the segmentation begins with mid= (Low+high)/2, whereas for Fibonacci lookups, the segmentation starts with mid = low + f[k-1]-1, and by the above, the number of elements in array A is now f[k]-1, that is, the number of leaders is f[k]- 1,mid the array into the left and right parts, the left side of the length is: f[k-1]-1, then the length of the side is (number leader-the length of the left-1), namely: (F[k]-1)-(F[k-1]-1) = F[k]-f[k-1]-1 = f[k-2]-1.
168. The core of Fibonacci lookup is:
170. 1) when Key=a[mid], find success;
172. 2) when Key<a[mid], the new search range is the first low to the mid-1, at this time the number of the range is f[k-1]-1, that is, the length of the left of the array, so in [Low, f[k-1]-1] within the scope of the search;
174. 3) when Key>a[mid], the new lookup range is mid+1 to high, at this time the number of ranges is f[k-2]-1, which is the length of the right of the array, so look in the [f[k-2]-1] range.

Fibonacci Lookup Method