这看起来很有意思：
int mid = s+( e-s )/2;
它没有正确地使用模算术。将arr[mid]与归一化与未规范化坐标以及如何应用于重新计算二分搜索循环的每次迭代的开始和结束。您希望在“归一化”空间中重新计算start和end，但mid需要根据透视索引值进行调整。
int main看起来也很可疑：

if( k >= arr[pivot] && k<= arr[n-1] ){
        cout<<" the index of the key is : " <<binarySearch( arr , n , pivot , ( n-1) , k)<<endl;
    }
    else{
        cout<<" the index of the key is : " <<binarySearch( arr , n , 0 , (pivot-1) , k)<<endl;
    }

如果我理解正确的话，该算法接受了一个可以旋转的排序数组。其中从stdin读取的输入可以是如下内容：

10 4                        // n = 10, key=4
9 10 11 12 13 1 2 3 4 5     // the sorted rotated array

所以在上面的例子中，如果key==4，那么我们希望返回8作为索引，因为array[8] == 4
这里是你的代码的一个清理版本。主要变化如下：
1.使用正确的标题包括
1.删除了可变长度数组并替换为std：：vector。
1.修正了binarySearch中的bug。此外，e参数实际上并不需要这个修复，所以我删除了它。
1.如果找不到元素，binarySearch将返回-1，而不是start
1.修正了main，以一致的方式调用binarySearch的大小和枢轴索引。不需要有两个版本的调用它。也不需要显式传递结束索引。

1. getPivot也有一些bug。所以我用类似的模运算修正了这个问题。

#include <iostream>
#include <vector>
using namespace std;
int getPivot(int arr[], int size) {
    int start = 0;
    int end = size - 1;
    if (size <= 1)
    {
        return 0;
    }
    while (start <= end)
    {
        int len = end - start + 1;
        int prev = (start + size - 1) % size;
        int mid = (start + end) / 2;
        if (arr[start] < arr[prev])
        {
            return start;
        }
        if (arr[start] <= arr[mid])
        {
            start = mid+1;
        }
        else
        {
            end = mid;
        }
    }
    return -1;
}
int binarySearch(int arr[], int size, int pivot, int key) {
    int start = 0;           // start and end are in the "normalized" index space
    int end = size - 1;
    while (start <= end) {
        int mid = (start + end) / 2;
        int actualMid = (pivot + mid) % size;  // actualMid is the denomalized conversion of mid using modulo arithmetic
        if (arr[actualMid] == key) {
            return actualMid;
        }
        else if (arr[actualMid] > key) {
            end = mid - 1;     // adjust end in normalized index space
        }
        else {
            start = mid + 1;   // adjust start in normalized index space
        }
    }
    return -1;
}
int main() {
    int n, k;
    cin >> n >> k;
    std::vector<int> arr(n);
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    int pivot = getPivot(arr.data(), n);
    cout << " the index of Pivot element is : " << pivot << endl;
    cout << " the index of the key is : " << binarySearch(arr.data(), n, pivot, k) << endl;
    return 0;
}

Java中使用二进制查找算法在旋转排序数组中检索索引

二叉查找算法伪代码流程：

1.将ans变量初始化为-1。
1.将startIndex设置为0，将endIndex设置为size - 1。
1.计算midIndex作为startIndex和endIndex的平均值。

1. startIndex小于endIndex时输入循环。

• 检查midIndex处的元素是否等于key：
• 如果为true，则将midIndex分配给ans并返回ans。
• 检查midIndex处的元素是否大于数组的第一个元素，并且键是否在第一个元素和midIndex处的元素的范围内：
• 如果为true，则将endIndex更新为midIndex - 1。
• 如果为false，则将startIndex更新为midIndex + 1。
• 将midIndex重新计算为更新后的startIndex和endIndex的平均值。
• 重复步骤5到7，直到不再满足while循环中的条件。

9.返回ans的值，如果找到键，则表示键的索引;如果没有找到，则返回-1。

迭代方法

public int findKey(int[] arr, int size, int key){
        int ans = -1;
        int startIndex = 0;
        int endIndex = size - 1;
        int midIndex = startIndex + (endIndex - startIndex) / 2;
        while (startIndex<=endIndex){
            if(arr[midIndex] == key){
                ans = midIndex;
                return ans;
            } else if (arr[midIndex] > arr[0] && (key >= arr[0] && key < arr[midIndex])) {
                endIndex = midIndex - 1;
            }else {
                startIndex = midIndex + 1;
            }
            midIndex = startIndex + (endIndex - startIndex) / 2;
        }
        return ans;
    }

在此发现全面的解决方案https://github.com/Amir36036/ds/blob/array/src/main/java/org/ds/array/FIndKeyINRotatedSortedArray.java