Рубрики

Поиск элемента в отсортированном и повернутом массиве

Элемент в отсортированном массиве можно найти за O (log n) с помощью бинарного поиска . Но предположим, что мы поворачиваем отсортированный по возрастанию массив в некотором неизвестном вам центре. Так, например, 1 2 3 4 5 может стать 3 4 5 1 2. Разработать способ найти элемент в повернутом массиве за O (log n) времени.

Input  : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
         key = 3
Output : Found at index 8

Input  : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
         key = 30
Output : Not found

Input : arr[] = {30, 40, 50, 10, 20}
        key = 10   
Output : Found at index 3

Все представленные здесь решения предполагают, что все элементы в массиве различны.

Идея состоит в том, чтобы найти точку поворота, разделить массив на два подмассива и вызвать бинарный поиск.
Основная идея для нахождения pivot состоит в том, что для отсортированного (в порядке возрастания) и pivoted массива элемент pivot является единственным элементом, для которого следующий элемент меньше его.
Используя приведенные выше критерии и методологию бинарного поиска, мы можем получить элемент разворота за O (logn) время

Input arr[] = {3, 4, 5, 1, 2}
Element to Search = 1
  1) Find out pivot point and divide the array in two
      sub-arrays. (pivot = 2) /*Index of 5*/
  2) Now call binary search for one of the two sub-arrays.
      (a) If element is greater than 0th element then
             search in left array
      (b) Else Search in right array
          (1 will go in else as 1 < 0th element(3))
  3) If element is found in selected sub-array then return index
     Else return -1.

Ниже приведена реализация вышеуказанного подхода:

C ++

/ * C ++ Программа для поиска элемента

   в отсортированном и развернутом массиве * /

#include <bits/stdc++.h>

using namespace std;

  
/ * Стандартная функция двоичного поиска * /

int binarySearch(int arr[], int low, 

                  int high, int key)

{

  if (high < low)

    return -1;

      

  int mid = (low + high)/2; / * низкий + (высокий - низкий) / 2; * /

  if (key == arr[mid])

    return mid;

      

  if (key > arr[mid])

    return binarySearch(arr, (mid + 1), high, key);

      

  // еще

    return binarySearch(arr, low, (mid -1), key);

}

  
/ * Функция для получения разворота. Для массива 3, 4, 5, 6, 1, 2

   возвращает 3 (индекс 6) * /

int findPivot(int arr[], int low, int high)

{

  // базовые случаи

  if (high < low) return -1;

  if (high == low) return low;

  

   int mid = (low + high)/2; / * низкий + (высокий - низкий) / 2; * /

   if (mid < high && arr[mid] > arr[mid + 1])

    return mid;

      

   if (mid > low && arr[mid] < arr[mid - 1])

    return (mid-1);

      

   if (arr[low] >= arr[mid])

    return findPivot(arr, low, mid-1);

      

   return findPivot(arr, mid + 1, high);

}

  
/ * Поиск ключа элемента в поворотном

   отсортированный массив arr [] размера n * /

int pivotedBinarySearch(int arr[], int n, int key)

{

  int pivot = findPivot(arr, 0, n-1);

  

  // Если мы не нашли пивот,

  // тогда массив вообще не вращается

  if (pivot == -1)

    return binarySearch(arr, 0, n-1, key);

  

  // Если мы нашли пивот, то сначала сравниваем с пивотом

  // и затем ищем в двух подмассивах вокруг оси

  if (arr[pivot] == key)

    return pivot;

      

  if (arr[0] <= key)

    return binarySearch(arr, 0, pivot-1, key);

      

    return binarySearch(arr, pivot+1, n-1, key);

}

  
/ * Программа драйвера для проверки вышеуказанных функций * /

int main()

{

  // Давайте искать 3 в массиве ниже

  int arr1[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};

  int n = sizeof(arr1)/sizeof(arr1[0]);

  int key = 3;

    

  // вызов функции

  cout << "Index of the element is : " << 

           pivotedBinarySearch(arr1, n, key);

             

  return 0;

}

С

/ * Программа для поиска элемента в отсортированном и развернутом массиве * /
#include <stdio.h>

  

int findPivot(int[], int, int);

int binarySearch(int[], int, int, int);

  
/ * Поиск ключа элемента в массиве pivoted отсортированного arrp []

   размером n * /

int pivotedBinarySearch(int arr[], int n, int key)

{

   int pivot = findPivot(arr, 0, n-1);

  

   // Если мы не нашли шарнир, то массив вообще не вращается

   if (pivot == -1)

       return binarySearch(arr, 0, n-1, key);

  

   // Если мы нашли пивот, то сначала сравниваем с пивотом, а затем

   // поиск в двух подмассивах вокруг оси

   if (arr[pivot] == key)

       return pivot;

   if (arr[0] <= key)

       return binarySearch(arr, 0, pivot-1, key);

   return binarySearch(arr, pivot+1, n-1, key);

}

  
/ * Функция для получения разворота. Для массива 3, 4, 5, 6, 1, 2 возвращается

   3 (индекс 6) * /

int findPivot(int arr[], int low, int high)

{

   // базовые случаи

   if (high < low)  return -1;

   if (high == low) return low;

  

   int mid = (low + high)/2;   / * низкий + (высокий - низкий) / 2; * /

   if (mid < high && arr[mid] > arr[mid + 1])

       return mid;

   if (mid > low && arr[mid] < arr[mid - 1])

       return (mid-1);

   if (arr[low] >= arr[mid])

       return findPivot(arr, low, mid-1);

   return findPivot(arr, mid + 1, high);

}

  
/ * Стандартная функция двоичного поиска * /

int binarySearch(int arr[], int low, int high, int key)

{

   if (high < low)

       return -1;

   int mid = (low + high)/2;  / * низкий + (высокий - низкий) / 2; * /

   if (key == arr[mid])

       return mid;

   if (key > arr[mid])

       return binarySearch(arr, (mid + 1), high, key);

   return binarySearch(arr, low, (mid -1), key);

}

  
/ * Программа драйвера для проверки вышеуказанных функций * /

int main()

{

   // Давайте искать 3 в массиве ниже

   int arr1[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};

   int n = sizeof(arr1)/sizeof(arr1[0]);

   int key = 3;

   printf("Index of the element is : %d",

        pivotedBinarySearch(arr1, n, key));

   return 0;

}

Джава

/ * Java-программа для поиска элемента

   в отсортированном и развернутом массиве * /

   

class Main

{

           

    / * Поиск ключа элемента в

       поворотный отсортированный массив arrp []

       размером n * /

    static int pivotedBinarySearch(int arr[], int n, int key)

    {

       int pivot = findPivot(arr, 0, n-1);

        

       // Если мы не нашли пивот, то

       // массив вообще не вращается

       if (pivot == -1)

           return binarySearch(arr, 0, n-1, key);

        

       // Если мы нашли пивот, то сначала

       // сравниваем с pivot и затем

       // поиск в двух подмассивах вокруг оси

       if (arr[pivot] == key)

           return pivot;

       if (arr[0] <= key)

           return binarySearch(arr, 0, pivot-1, key);

       return binarySearch(arr, pivot+1, n-1, key);

    }

       

    / * Функция для получения разворота. Для массива

       3, 4, 5, 6, 1, 2 возвращается

       3 (индекс 6) * /

    static int findPivot(int arr[], int low, int high)

    {

       // базовые случаи

       if (high < low)  

            return -1;

       if (high == low) 

            return low;

         

       / * низкий + (высокий - низкий) / 2; * /

       int mid = (low + high)/2;   

       if (mid < high && arr[mid] > arr[mid + 1])

           return mid;

       if (mid > low && arr[mid] < arr[mid - 1])

           return (mid-1);

       if (arr[low] >= arr[mid])

           return findPivot(arr, low, mid-1);

       return findPivot(arr, mid + 1, high);

    }

       

    / * Стандартная функция двоичного поиска * /

    static int binarySearch(int arr[], int low, int high, int key)

    {

       if (high < low)

           return -1;

         

       / * низкий + (высокий - низкий) / 2; * /       

       int mid = (low + high)/2;  

       if (key == arr[mid])

           return mid;

       if (key > arr[mid])

           return binarySearch(arr, (mid + 1), high, key);

       return binarySearch(arr, low, (mid -1), key);

    }

    

    // основная функция

    public static void main(String args[])

    {

       // Давайте искать 3 в массиве ниже

       int arr1[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};

       int n = arr1.length;

       int key = 3;

       System.out.println("Index of the element is : "

                      + pivotedBinarySearch(arr1, n, key));

    }

}

python3

# Программа Python для поиска элемента
# в отсортированном и развернутом массиве

  
# Поиск ключа элемента в поворотном
# отсортированный массив arrp [] размера n

def pivotedBinarySearch(arr, n, key):

  

    pivot = findPivot(arr, 0, n-1);

  

    # Если мы не нашли стержень,

    # тогда массив вообще не вращается

    if pivot == -1:

        return binarySearch(arr, 0, n-1, key);

  

    # Если мы нашли пивот, то сначала

    # сравнить с Pivot, а затем

    # поиск в двух подмассивах вокруг оси

    if arr[pivot] == key:

        return pivot

    if arr[0] <= key:

        return binarySearch(arr, 0, pivot-1, key);

    return binarySearch(arr, pivot+1, n-1, key);

  

  
# Функция для получения разворота. Для массива
# 3, 4, 5, 6, 1, 2 возвращается 3
# (индекс 6)

def findPivot(arr, low, high):

      

    # базовые случаи

    if high < low:

        return -1

    if high == low:

        return low

      

    #low + (высокий - низкий) / 2;

    mid = int((low + high)/2)

      

    if mid < high and arr[mid] > arr[mid + 1]:

        return mid

    if mid > low and arr[mid] < arr[mid - 1]:

        return (mid-1)

    if arr[low] >= arr[mid]:

        return findPivot(arr, low, mid-1)

    return findPivot(arr, mid + 1, high)

  
# Стандартная функция двоичного поиска * /

def binarySearch(arr, low, high, key):

  

    if high < low:

        return -1

          

    #low + (высокий - низкий) / 2;

    mid = int((low + high)/2)

      

    if key == arr[mid]:

        return mid

    if key > arr[mid]:

        return binarySearch(arr, (mid + 1), high,

                                            key);

    return binarySearch(arr, low, (mid -1), key);

  

  
# Драйверная программа для проверки вышеуказанных функций * /
# Давайте искать 3 в массиве ниже

arr1 = [5, 6, 7, 8, 9, 10, 1, 2, 3]

n = len(arr1)

key = 3

print("Index of the element is : "

      pivotedBinarySearch(arr1, n, key))

        
# Это предоставлено Смитой Динешем Семвалом

C #

// C # программа для поиска элемента
// в отсортированном и развернутом массиве

using System;

  

class main {

  

    // Ищет ключ элемента в

    // поворотный отсортированный массив arrp []

    // размера n

    static int pivotedBinarySearch(int[] arr,

                                int n, int key)

    {

        int pivot = findPivot(arr, 0, n - 1);

  

        // Если мы не нашли пивот, то

        // массив вообще не вращается

        if (pivot == -1)

            return binarySearch(arr, 0, n - 1, key);

  

        // Если мы нашли пивот, то сначала

        // сравниваем с pivot и затем

        // поиск в двух подмассивах вокруг оси

        if (arr[pivot] == key)

            return pivot;

  

        if (arr[0] <= key)

            return binarySearch(arr, 0, pivot - 1, key);

  

        return binarySearch(arr, pivot + 1, n - 1, key);

    }

  

    / * Функция для получения разворота. Для массива

    3, 4, 5, 6, 1, 2 возвращается

    3 (индекс 6) * /

    static int findPivot(int[] arr, int low, int high)

    {

        // базовые случаи

        if (high < low)

            return -1;

        if (high == low)

            return low;

  

        / * низкий + (высокий - низкий) / 2; * /

        int mid = (low + high) / 2;

  

        if (mid < high && arr[mid] > arr[mid + 1])

            return mid;

  

        if (mid > low && arr[mid] < arr[mid - 1])

            return (mid - 1);

  

        if (arr[low] >= arr[mid])

            return findPivot(arr, low, mid - 1);

  

        return findPivot(arr, mid + 1, high);

    }

  

    / * Стандартная функция двоичного поиска * /

    static int binarySearch(int[] arr, int low,

                            int high, int key)

    {

        if (high < low)

            return -1;

  

        / * низкий + (высокий - низкий) / 2; * /

        int mid = (low + high) / 2;

  

        if (key == arr[mid])

            return mid;

        if (key > arr[mid])

            return binarySearch(arr, (mid + 1), high, key);

  

        return binarySearch(arr, low, (mid - 1), key);

    }

  

    // Код драйвера

    public static void Main()

    {

        // Давайте искать 3 в массиве ниже

        int[] arr1 = { 5, 6, 7, 8, 9, 10, 1, 2, 3 };

        int n = arr1.Length;

        int key = 3;

        Console.Write("Index of the element is : "

                    + pivotedBinarySearch(arr1, n, key));

    }

}

  
// Этот код предоставлен vt_m.

PHP

<?php
// PHP программа для поиска элемента
// в отсортированном и развернутом массиве

  
// Стандартная функция двоичного поиска

function binarySearch($arr, $low

                      $high, $key)

{

    if ($high < $low)

        return -1;

          

    / * низкий + (высокий - низкий) / 2; * /    

    $mid = floor($low + $high) / 2;

      

    if ($key == $arr[$mid])

        return $mid;

          

    if ($key > $arr[$mid])

        return binarySearch($arr, ($mid + 1),

                                $high, $key);

          

    else

        return binarySearch($arr, $low,

                      ($mid -1), $key);

}

  
// Функция для получения разворота.
// Для массива 3, 4, 5, 6, 1, 2
// возвращает 3 (индекс 6)

function findPivot($arr, $low, $high)

{

      

    // базовые случаи

    if ($high < $low

        return -1;

    if ($high == $low

        return $low;

      

    / * низкий + (высокий - низкий) / 2; * /

    $mid = ($low + $high)/2; 

    if ($mid < $high and $arr[$mid] > 

                     $arr[$mid + 1])

        return $mid;

          

    if ($mid > $low and $arr[$mid] < 

                    $arr[$mid - 1])

        return ($mid - 1);

          

    if ($arr[$low] >= $arr[$mid])

        return findPivot($arr, $low,

                          $mid - 1);

          

    return findPivot($arr, $mid + 1, $high);

}

  
// Ищет ключ элемента
// в поворотном отсортированном массиве
// arr [] размера n * /

function pivotedBinarySearch($arr, $n, $key)

{

    $pivot = findPivot($arr, 0, $n - 1);

      

    // Если мы не нашли пивот,

    // тогда массив не вращается

    // совсем

    if ($pivot == -1)

        return binarySearch($arr, 0, 

                       $n - 1, $key);

      

    // Если мы нашли пивот,

    // затем сначала сравни

    // с поворотом, а затем

    // поиск в двух подмассивах

    // вокруг разворота

    if ($arr[$pivot] == $key)

        return $pivot;

          

    if ($arr[0] <= $key)

        return binarySearch($arr, 0, 

                   $pivot - 1, $key);

          

        return binarySearch($arr, $pivot + 1, 

                                $n - 1, $key);

}

  
// Код драйвера
// Давайте искать 3
// в массиве ниже

$arr1 = array(5, 6, 7, 8, 9, 10, 1, 2, 3);

$n = count($arr1);

$key = 3;

  
// вызов функции

echo "Index of the element is : "

      pivotedBinarySearch($arr1, $n, $key);

              
// Этот код предоставлен anuj_67.
?>


Выход:

Index of the element is : 8

Сложность времени O (logn). Спасибо Ajay Mishra за первоначальное решение.

Улучшенное решение:
Мы можем искать элемент за один проход бинарного поиска. Идея состоит в том, чтобы искать

1) Find middle point mid = (l + h)/2
2) If key is present at middle point, return mid.
3) Else If arr[l..mid] is sorted
    a) If key to be searched lies in range from arr[l]
       to arr[mid], recur for arr[l..mid].
    b) Else recur for arr[mid+1..h]
4) Else (arr[mid+1..h] must be sorted)
    a) If key to be searched lies in range from arr[mid+1]
       to arr[h], recur for arr[mid+1..h].
    b) Else recur for arr[l..mid] 

Ниже приведена реализация вышеуказанной идеи:

C ++

// Поиск элемента в отсортированном и повернутом
// массив с использованием одного прохода двоичного поиска
#include <bits/stdc++.h>

using namespace std;

  
// Возвращает индекс ключа в arr [l..h] if
// ключ присутствует, иначе возвращает -1

int search(int arr[], int l, int h, int key)

{

    if (l > h) return -1;

  

    int mid = (l+h)/2;

    if (arr[mid] == key) return mid;

  

    / * Если отсортирован arr [l ... mid] * /

    if (arr[l] <= arr[mid])

    {

        / * Поскольку этот подмассив отсортирован, мы можем быстро

        проверить, лежит ли ключ пополам или в другой половине * /

        if (key >= arr[l] && key <= arr[mid])

        return search(arr, l, mid-1, key);

         / * Если ключ не лежит в первой половине подмассива,

           Разделите другую половину на два подмассива,

           так что мы можем быстро проверить, лежит ли ключ

           в другой половине * /

        return search(arr, mid+1, h, key);

    }

  

    / * Если arr [l..mid] первый подмассив не отсортирован, то arr [mid ... h]

    должен быть отсортирован подмассив * /

    if (key >= arr[mid] && key <= arr[h])

        return search(arr, mid+1, h, key);

  

    return search(arr, l, mid-1, key);

}

  
// Драйвер программы

int main()

{

    int arr[] = {4, 5, 6, 7, 8, 9, 1, 2, 3};

    int n = sizeof(arr)/sizeof(arr[0]);

    int key = 6;

    int i = search(arr, 0, n-1, key);

  

    if (i != -1)

    cout << "Index: " << i << endl;

    else

    cout << "Key not found";

}

Джава

/ * Java-программа для поиска элемента в

   отсортированный и повернутый массив с помощью

   один проход бинарного поиска * /

   

class Main

{

    // Возвращает индекс ключа в arr [l..h]

    // если ключ присутствует, иначе возвращает -1

    static int search(int arr[], int l, int h, int key)

    {

        if (l > h) 

            return -1;

        

        int mid = (l+h)/2;

        if (arr[mid] == key)

            return mid;

        

        / * Если arr [l ... mid] первый подмассив отсортирован * /

        if (arr[l] <= arr[mid])

        {

            / * Поскольку этот подмассив отсортирован, мы

               может быстро проверить, лежит ли ключ

               половина или другая половина * /

            if (key >= arr[l] && key <= arr[mid])

               return search(arr, l, mid-1, key);

            / * Если ключ не лежит в первой половине подмассива,

           Разделите другую половину на два подмассива,

           так что мы можем быстро проверить, лежит ли ключ

           в другой половине * /

            return search(arr, mid+1, h, key);

        }

        

        / * Если arr [l..mid] первый подмассив не отсортирован,

           тогда arr [mid ... h] должен быть отсортирован subarry * /

        if (key >= arr[mid] && key <= arr[h])

            return search(arr, mid+1, h, key);

        

        return search(arr, l, mid-1, key);

    }

    

    //основная функция

    public static void main(String args[])

    {

        int arr[] = {4, 5, 6, 7, 8, 9, 1, 2, 3};

        int n = arr.length;

        int key = 6;

        int i = search(arr, 0, n-1, key);

        if (i != -1

            System.out.println("Index: " + i);

        else

            System.out.println("Key not found");

    }

}

python3

# Поиск элемента в отсортированном и повернутом массиве с помощью
# один проход бинарного поиска

  
# Возвращает индекс ключа в arr [l..h], если ключ присутствует,
# иначе возвращает -1

def search (arr, l, h, key):

    if l > h:

        return -1

      

    mid = (l + h) // 2

    if arr[mid] == key:

        return mid

  

    # Если отсортирован arr [l ... mid]

    if arr[l] <= arr[mid]:

  

        # Поскольку этот подмассив отсортирован, мы можем быстро

        # проверить, лежит ли ключ пополам или в другой половине

        if key >= arr[l] and key <= arr[mid]:

            return search(arr, l, mid-1, key)

        return search(arr, mid+1, h, key)

  

    # Если arr [l..mid] не отсортирован, то arr [mid ... r]

    # должен быть отсортирован

    if key >= arr[mid] and key <= arr[h]:

        return search(a, mid+1, h, key)

    return search(arr, l, mid-1, key)

  
# Драйверная программа

arr = [4, 5, 6, 7, 8, 9, 1, 2, 3]

key = 6

i = search(arr, 0, len(arr)-1, key)

if i != -1:

    print ("Index: %d"%i)

else:

    print ("Key not found")

  
# Этот код предоставлен Shreyanshi Arun

C #

/ * C # программа для поиска элемента в
отсортированный и повернутый массив с помощью
один проход бинарного поиска * /

using System;

  

class GFG {

      

    // Возвращает индекс ключа в arr [l..h]

    // если ключ присутствует, иначе

    // возвращает -1

    static int search(int []arr, int l, int h,

                                       int key)

    {

        if (l > h) 

            return -1;

      

        int mid = (l + h) / 2;

          

        if (arr[mid] == key)

            return mid;

      

        / * Если отсортирован arr [l ... mid] * /

        if (arr[l] <= arr[mid])

        {

              

            / * Поскольку этот подмассив отсортирован, мы

            может быстро проверить, лежит ли ключ

            половина или другая половина * /

            if (key >= arr[l] && key <= arr[mid])

            return search(arr, l, mid - 1, key);

      

            return search(arr, mid + 1, h, key);

        }

      

        / * Если arr [l..mid] не отсортирован,

        тогда arr [mid ... r] должен быть отсортирован * /

        if (key >= arr[mid] && key <= arr[h])

            return search(arr, mid + 1, h, key);

      

        return search(arr, l, mid - 1, key);

    }

  

    // основная функция

    public static void Main()

    {

        int []arr = {4, 5, 6, 7, 8, 9, 1, 2, 3};

        int n = arr.Length;

        int key = 6;

        int i = search(arr, 0, n - 1, key);

          

        if (i != -1) 

            Console.WriteLine("Index: " + i);

        else

            Console.WriteLine("Key not found");

    }

}

  
// Этот код предоставлен anuj_67.

PHP

<?php
// Поиск элемента в отсортированном и повернутом
// массив с использованием одного прохода двоичного поиска

  
// Возвращает индекс ключа в arr [l..h] if
// ключ присутствует, иначе возвращает -1

function search($arr, $l, $h, $key)

{

    if ($l > $h) return -1;

  

    $mid = ($l + $h) / 2;

    if ($arr[$mid] == $key)

        return $mid;

  

    / * Если отсортирован arr [l ... mid] * /

    if ($arr[$l] <= $arr[$mid])

    {

          

        / * Поскольку этот подмассив

           отсортировано, мы можем быстро

           проверьте, лежит ли ключ в

           половина или другая половина * /

        if ($key >= $arr[$l] && 

            $key <= $arr[$mid])

                return search($arr, $l

                       $mid - 1, $key);

  

        return search($arr, $mid + 1,

                           $h, $key);

    }

  

    / * Если arr [l..mid] не

       отсортировано, затем обр

       должны быть отсортированы * /

    if ($key >= $arr[$mid] && 

          $key <= $arr[$h])

        return search($arr, $mid + 1, 

                            $h, $key);

  

    return search($arr, $l

             $mid-1, $key);

}

  

    // Код драйвера

    $arr = array(4, 5, 6, 7, 8, 9, 1, 2, 3);

    $n = sizeof($arr);

    $key = 6;

    $i = search($arr, 0, $n-1, $key);

  

    if ($i != -1)

        echo "Index: ", floor($i) ," \n";

    else

        echo "Key not found";

  
// Этот код предоставлен ajit
?>


Выход:

Index: 2

Спасибо Gaurav Ahirwar за предложенное выше решение.

Как обрабатывать дубликаты?
Поиск во время O (Logn) не представляется возможным во всех случаях, когда допускаются дубликаты. Например, рассмотрите возможность поиска 0 в {2, 2, 2, 2, 2, 2, 2, 2, 0, 2} и {2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 , 2}. Не представляется возможным решить, повторяться ли для левой или правой половины, выполняя постоянное число сравнений в середине.

Похожие статьи:
Найти минимальный элемент в отсортированном и повернутом массиве
По сортированному и повернутому массиву найдите, есть ли пара с заданной суммой.

Пожалуйста, пишите комментарии, если вы обнаружите какую-либо ошибку в приведенных выше кодах / алгоритмах, или найдете другие способы решения той же проблемы.

Рекомендуемые посты:

Поиск элемента в отсортированном и повернутом массиве

0.00 (0%) 0 votes