mirror of
https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git
synced 2023-10-11 13:05:55 +08:00
141 lines
3.9 KiB
C++
141 lines
3.9 KiB
C++
/**
|
|
* \file
|
|
* \brief [Ternary search](https://en.wikipedia.org/wiki/Ternary_search)
|
|
* algorithm
|
|
*
|
|
* This is a divide and conquer algorithm.
|
|
* It does this by dividing the search space by 3 parts and
|
|
* using its property (usually monotonic property) to find
|
|
* the desired index.
|
|
*
|
|
* * Time Complexity : O(log3 n)
|
|
* * Space Complexity : O(1) (without the array)
|
|
*/
|
|
|
|
#include <iostream>
|
|
|
|
/**
|
|
* The absolutePrecision can be modified to fit preference but
|
|
* it is recommended to not go lower than 10 due to errors that
|
|
* may occur.
|
|
*/
|
|
#define absolutePrecision 10
|
|
/**
|
|
* The value of _target should be decided or can be decided later
|
|
* by using the variable of the function.
|
|
*/
|
|
#define _target 10
|
|
|
|
#define MAX 10000000 ///< Maximum length of array
|
|
|
|
/**
|
|
* get_input function is to receive input from standard IO
|
|
* @todo @christianbender Get input from STDIO or write input to memory as done
|
|
* above.
|
|
*/
|
|
void get_input() {}
|
|
|
|
/**
|
|
* This is the iterative method of the ternary search which returns the index of
|
|
* the element.
|
|
* \param[in] left lower interval limit
|
|
* \param[in] right upper interval limit
|
|
* \param[in] A array to search in
|
|
* \param[in] target value to search for
|
|
* \returns index where the target value was found
|
|
* \returns -1 if target value not found
|
|
*/
|
|
int it_ternary_search(int left, int right, int A[], int target) {
|
|
while (1) {
|
|
if (left < right) {
|
|
if (right - left < absolutePrecision) {
|
|
for (int i = left; i <= right; i++)
|
|
if (A[i] == target)
|
|
return i;
|
|
|
|
return -1;
|
|
}
|
|
|
|
int oneThird = (left + right) / 3 + 1;
|
|
int twoThird = (left + right) * 2 / 3 + 1;
|
|
|
|
if (A[oneThird] == target)
|
|
return oneThird;
|
|
else if (A[twoThird] == target)
|
|
return twoThird;
|
|
|
|
else if (target > A[twoThird])
|
|
left = twoThird + 1;
|
|
else if (target < A[oneThird])
|
|
right = oneThird - 1;
|
|
|
|
else
|
|
left = oneThird + 1, right = twoThird - 1;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is the recursive method of the ternary search which returns the index of
|
|
* the element.
|
|
* \param[in] left lower interval limit
|
|
* \param[in] right upper interval limit
|
|
* \param[in] A array to search in
|
|
* \param[in] target value to search for
|
|
* \returns index where the target value was found
|
|
* \returns -1 if target value not found
|
|
*/
|
|
int rec_ternary_search(int left, int right, int A[], int target) {
|
|
if (left < right) {
|
|
if (right - left < absolutePrecision) {
|
|
for (int i = left; i <= right; i++)
|
|
if (A[i] == target)
|
|
return i;
|
|
|
|
return -1;
|
|
}
|
|
|
|
int oneThird = (left + right) / 3 + 1;
|
|
int twoThird = (left + right) * 2 / 3 + 1;
|
|
|
|
if (A[oneThird] == target)
|
|
return oneThird;
|
|
if (A[twoThird] == target)
|
|
return twoThird;
|
|
|
|
if (target < A[oneThird])
|
|
return rec_ternary_search(left, oneThird - 1, A, target);
|
|
if (target > A[twoThird])
|
|
return rec_ternary_search(twoThird + 1, right, A, target);
|
|
|
|
return rec_ternary_search(oneThird + 1, twoThird - 1, A, target);
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ternary_search is a template function
|
|
* You could either use it_ternary_search or rec_ternary_search according to
|
|
* preference.
|
|
* \param [in] N length of array
|
|
* \param[in] A array to search in
|
|
* \param[in] target value to search for
|
|
*/
|
|
void ternary_search(int N, int A[], int target) {
|
|
std::cout << it_ternary_search(0, N - 1, A, target) << '\t';
|
|
std::cout << rec_ternary_search(0, N - 1, A, target) << '\t';
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
/** Main function */
|
|
int main() {
|
|
int N = 21;
|
|
int A[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 10};
|
|
get_input();
|
|
ternary_search(N, A, _target);
|
|
return 0;
|
|
}
|