Найти минимум отсортированного и сдвинутого массива с лучшей, чем O (n), сложностью по времени

Question

У нас есть задание для поиска минимального элемента отсортированного массива, который впоследствии смещается вправо. Например: [1, 5, 6, 19, 56, 101] становится [19, 56, 101, 1, 5, 6]. Метод должен быть реализован с использованием алгоритма «разделяй и властвуй», и он должен иметь лучшую асимптотическую сложность по времени, чем O (n). РЕДАКТИРОВАТЬ: я забыл добавить, что элементы в массиве являются уникальными.

Я уже реализовал метод и хотел спросить, лучше ли это, чем O (n), и есть ли способы улучшить мой метод.

public class FindMinimum {
    public void findMinimum(int[] arr) {

        // the recursive method ends when the length of the array is smaller than 2
        if (arr.length < 2) {
            return;
        }

        int mid = arr.length / 2;

        /*
         * if the array length is greater or the same as two, check if the middle
         * element is smaller as the element before that. And print the middle element
         * if it's true.
         */
        if (arr.length >= 2) {
            if (arr[mid - 1] > arr[mid]) {
                System.out.println("Minimum: " + arr[mid]);
                return;
            }
        }

        /*
         * separate the array in two sub-arrays through the middle and start the method
         * with those two arrays again.
         */
        int[] leftArr = new int[mid];
        int[] rightArr = new int[arr.length - mid];
        for (int i = 0; i < mid; i++) {
            leftArr[i] = arr[i];
        }
        for (int i = mid; i < arr.length; i++) {
            rightArr[i - mid] = arr[i];
        }
        findMinimum(leftArr);
        findMinimum(rightArr);
    }
}

Answer 1

В Java вы можете использовать List, потому что вы можете создать Sublist.

private Integer findMinimum(List<Integer> list) {
    if (list.size() < 2)
        return list.get(0);

    int mid = list.size() / 2;

    // create left and right list
    List<Integer> leftList = list.subList(0, mid);
    List<Integer> rightList = list.subList(mid, list.size());

    if (leftList.get(leftList.size() - 1) <= rightList.get(rightList.size() - 1))
        return findMin(leftList);
    else
        return findMin(rightList);
}

При создании подсписка с Java копия отсутствует.Таким образом, для создания нового подсписка требуется сложность O (1).Таким образом, функция имеет сложность O (logn).

Answer 2

Это мое новое решение, никуда не копируя массив.

public class FindMinimum {

    public void findMinimum(int[] arr) {
        findMinimumSub(arr, 0, arr.length - 1, 2);
    }

    private void findMinimumSub(int[] arr, int start, int end, int size) {
        // the recursive method ends when the length of the array is smaller than 2
        if ((end - start) < 2) {
            if (arr[end] > arr[start])
                System.out.println("Minimum: " + arr[start]);
            else
                System.out.println("Minimum: " + arr[end]);
            return;
        }

        int mid = arr.length / size;

        if (arr[start] > arr[end]) {
            // right side
            start += mid;
            findMinimumSub(arr, start, end, size * 2);
        }
        else {
            // left side
            findMinimumSub(arr, start, mid, size * 2);
        }
    }
}