Ternary Search in C++

Ternary search is an efficient search algorithm used to find an element in a sorted array. It is a more efficient version of the binary search. In this article, we will learn how to implement the ternary search in C++.

How Ternary Search Works?

Ternary search divides the array (or search space) into three parts by calculating two midpoints, then it compares the target value with the elements at these midpoints to determine which segment to search next. This process continues recursively until the target element is found or the search space is empty.

Algorithm for Ternary Search in C++

• Start by initializing two pointers, left and right, which initially point to the first and last elements of the array, respectively.
  
• Divide the current search space into three parts by calculating two midpoints, mid1 and mid2:
  
  • mid1 is calculated as left + (right - left) / 3
  • mid2 is calculated as right - (right - left) / 3
  • This division effectively splits the array into [left, mid1], (mid1, mid2), and [mid2, right] segments.
    
• Check if the target value equals the elements at mid1 or mid2. If found, return the index of the target element.
  • If the target is less than the element at mid1, update the right pointer to mid1 - 1 to search in the [left, mid1-1] segment.
  • If the target is greater than the element at mid2, update the left pointer to mid2 + 1 to search in the [mid2+1, right] segment.
  • If the target is between the elements at mid1 and mid2, update the left pointer to mid1 + 1 and the right pointer to mid2 - 1 to search in the (mid1+1, mid2-1) segment.
    
• Repeat the process with the updated search space until the target is found or the search space is exhausted.
  • If the target is not found after exhausting the search space, return a value indicating that the target is not present in the array.

C++ Program to Implement Ternary Search

#include <iostream>
using namespace std;

int ternarySearch(int arr[], int l, int r, int key)
{
    while (r >= l) {
        int mid1 = l + (r - l) / 3;
        int mid2 = r - (r - l) / 3;

        // Check if the key is present at mid1
        if (arr[mid1] == key) {
            return mid1;
        }

        // Check if the key is present at mid2
        if (arr[mid2] == key) {
            return mid2;
        }

        // Determine which segment to search next
        if (key < arr[mid1]) {
            r = mid1 - 1;
        }
        else if (key > arr[mid2]) {
            l = mid2 + 1;
        }
        else {
            l = mid1 + 1;
            r = mid2 - 1;
        }
    }

    // If the element is not found
    return -1;
}

int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int key = 5;

    int index = ternarySearch(arr, 0, n - 1, key);

    if (index != -1) {
        cout << "Element found at index " << index << endl;
    }
    else {
        cout << "Element not found in the array" << endl;
    }

    return 0;
}

Element found at index 4

Time Complexity

Best, Average, and Worst Case:

• Best Case: O(1), if the target element is found at one of the division points.
• Average and Worst Case: O(log⁡₃n), as each step reduces the array size to about one-third, so it takes about O(log⁡₃n)steps to narrow down to the target element.

Space Complexity

• Iterative Version: O(1)
• Recursive Version: O(log⁡₃n)

Ternary Search vs. Binary Search in C++

Ternary search and binary search are both divide-and-conquer algorithms used to find elements in a sorted array. Binary search splits the search space in half, checking the middle element, and then discarding the half where the target cannot be. Ternary search, on the other hand, splits the array into three parts by checking two midpoints. While ternary search reduces the search space more aggressively, it involves more comparisons and computational overhead per iteration. As a result, binary search often performs better in practice due to its lower constant factors, despite having a similar logarithmic time complexity.