Bir öğeyi aramanın verimli yolu

Geçenlerde bir röportaj yaptım ve bana bir " arama " sorusu sordular .
Soru şuydu:

Her bir öğenin bitişiğindeki öğeleriyle karşılaştırıldığı +1veya -1bunlarla karşılaştırıldığı bir (pozitif) tamsayı dizisi olduğunu varsayalım .

Misal:

array = [4,5,6,5,4,3,2,3,4,5,6,7,8];

Şimdi 7konumunu arayın ve geri dönün.

Bu cevabı verdim:

Değerleri geçici bir dizide saklayın, sıralayın ve ardından ikili arama uygulayın.

Öğe bulunursa, geçici dizideki konumunu döndürün.
(Sayı iki kez oluyorsa, ilk geçtiği yeri döndür)

Ancak, bu cevapla tatmin olmadılar.

Doğru cevap nedir?

Genellikle 1'den büyük adımlarla doğrusal bir arama yapabilirsiniz. Önemli gözlem, örneğin array[i] == 4ve 7 henüz ortaya çıkmadıysa, 7 için bir sonraki adayın indekste olmasıdır i+3. Bir sonraki geçerli adaya art arda doğrudan giden bir while döngüsü kullanın.

İşte biraz genelleştirilmiş bir uygulama. Dizideki ilk oluşumunu bulur k(+ = 1 kısıtlamasına tabidir) veya -1gerçekleşmezse:

#include <stdio.h>
#include <stdlib.h>

int first_occurence(int k, int array[], int n);

int main(void){
    int a[] = {4,3,2,3,2,3,4,5,4,5,6,7,8,7,8};
    printf("7 first occurs at index %d\n",first_occurence(7,a,15));
    printf("but 9 first \"occurs\" at index %d\n",first_occurence(9,a,15));
    return 0;
}

int first_occurence(int k, int array[], int n){
    int i = 0;
    while(i < n){
        if(array[i] == k) return i;
        i += abs(k-array[i]);
    }
    return -1;
}

çıktı:

7 first occurs at index 11
but 9 first "occurs" at index -1

Yaklaşımınız çok karmaşık. Her dizi elemanını incelemeniz gerekmez. İlk değerdir 4yüzden, 7olduğu en azından 7-4 uzak elemanları ve o atlayabilirsiniz.

#include <stdio.h>
#include <stdlib.h>

int main (void)
{
    int array[] = {4,5,6,5,4,3,2,3,4,5,6,7,8};
    int len = sizeof array / sizeof array[0];
    int i = 0;
    int steps = 0;
    while (i < len && array[i] != 7) {
        i += abs(7 - array[i]);
        steps++;
    }

    printf("Steps %d, index %d\n", steps, i);
    return 0;
}

Program çıkışı:

Steps 4, index 11

Düzenleme: @Raphael Miedl ve @Martin Zabel'in yorumlarından sonra iyileştirildi.

Geleneksel doğrusal aramanın bir varyasyonu, gitmek için iyi bir yol olabilir. Bir unsur seçelim diyelim array[i] = 2. Şimdi, array[i + 1]1 veya 3 (tek) olacak,array[i + 2] olacak, (yalnızca pozitif tamsayılar) 2 veya 4 (çift sayı) olacaktır.

Böyle devam edince, bir model gözlemlenebilir - array[i + 2*n]çift ​​sayıları tutacaktır ve bu nedenle tüm bu indeksler göz ardı edilebilir.

Ayrıca bunu görebiliriz

array[i + 3] = 1 or 3 or 5
array[i + 5] = 1 or 3 or 5 or 7

bu nedenle, daha sonra indeks i + 5kontrol edilmelidir ve indekste bulunan değere bağlı olarak kontrol edilecek bir sonraki indeksi belirlemek için bir while döngüsü kullanılabilir i + 5.

Bu karmaşıklığa sahipken O(n)(asimptotik karmaşıklık açısından doğrusal zaman), tüm endeksler ziyaret edilmediğinden pratik açıdan normal bir doğrusal aramadan daha iyidir.

Açıkçası, eğer array[i](başlangıç ​​noktamız) tuhaf olsaydı tüm bunlar tersine çevrilecek .

John Coleman tarafından sunulan yaklaşım, görüşmecinin büyük olasılıkla umduğu şeydi.
Biraz daha karmaşık hale gelmek istiyorsanız, beklenen atlama uzunluğunu artırabilirsiniz:
Hedef değeri k olarak adlandırın . P konumundaki ilk elemanın değeri v ile başlayın ve mutlak değer av ile kv dv farkını çağırın . Negatif aramaları hızlandırmak için, o konumundaki diğer u değeri olarak son öğeye bir göz atın: dv × du negatifse, k mevcutsa (herhangi bir k oluşumu kabul edilebilirse, indeks aralığını burada ikili aramanın yaptığı gibi daraltabilirsiniz). Av + au dizinin uzunluğundan büyükse, k yoktur. (Eğer dv × du sıfırsa, v veya u k'ye eşittir.)
İndeks geçerliliğini atlamak: Sıranın ortada k ile v'ye dönebileceği ("sonraki") konumu araştırın o = p + 2*av.
Dv × du negatifse, p + av'dan o-au'ya k (yinelemeli olarak?) Bulun;
sıfır ise, u eşittir k at o.
Du dv eşittir ve varsa ortada değer k değildir veya au av aşıyor,
ya da başarısız + av için o-au, s dan k bulmak için
izinp=o; dv=du; av=au; ve sondalama tutun.
(60'lı yılların metinlerine tam bir geri dönüş için Courier ile görüntüleyin. Benim "2. düşüncem"o = p + 2*av - 1, du equals dv'yi engeller .)

AŞAMA 1

İlk elemanla başlayın ve 7 olup olmadığını kontrol edin. Diyelim ki cmevcut konumun indeksi. Yani, başlangıçta c = 0.

ADIM 2

7 ise, dizini buldunuz. Bu c. Dizinin sonuna ulaştıysanız, çıkın.

AŞAMA 3

Değilse, |array[c]-7|endeks başına yalnızca bir birim ekleyebileceğiniz için 7 en az konum uzakta olmalıdır . Bu nedenle, |array[c]-7|mevcut indeksinize ekleyin , c ve kontrol etmek için ADIM 2'ye tekrar gidin.

En kötü durumda, alternatif 1 ve -1'ler olduğunda, zaman karmaşıklığı O (n) değerine ulaşabilir, ancak ortalama durumlar hızlı bir şekilde teslim edilir.

Burada java uygulamasını veriyorum ...

public static void main(String[] args) 
{       
    int arr[]={4,5,6,5,4,3,2,3,4,5,6,7,8};
    int pos=searchArray(arr,7);

    if(pos==-1)
        System.out.println("not found");
    else
        System.out.println("position="+pos);            
}

public static int searchArray(int[] array,int value)
{
    int i=0;
    int strtValue=0;
    int pos=-1;

    while(i<array.length)
    {
        strtValue=array[i];

        if(strtValue<value)
        {
            i+=value-strtValue;
        }
        else if (strtValue==value)
        {
            pos=i;
            break;
        }
        else
        {
            i=i+(strtValue-value);
        }       
    }

    return pos;
}

İşte böl ve yönet tarzı bir çözüm. Daha fazla defter tutma pahasına, daha fazla öğeyi atlayabiliriz; soldan sağa taramak yerine ortada test edin ve her iki yönde de atlayın .

#include <stdio.h>                                                               
#include <math.h>                                                                

int could_contain(int k, int left, int right, int width);                        
int find(int k, int array[], int lower, int upper);   

int main(void){                                                                  
    int a[] = {4,3,2,3,2,3,4,5,4,5,6,7,8,7,8};                                   
    printf("7 first occurs at index %d\n",find(7,a,0,14));                       
    printf("but 9 first \"occurs\" at index %d\n",find(9,a,0,14));               
    return 0;                                                                    
}                                                                                

int could_contain(int k, int left, int right, int width){                        
  return (width >= 0) &&                                                         
         (left <= k && k <= right) ||                                            
         (right <= k && k <= left) ||                                            
         (abs(k - left) + abs(k - right) < width);                               
}                                                                                

int find(int k, int array[], int lower, int upper){                              
  //printf("%d\t%d\n", lower, upper);                                            

  if( !could_contain(k, array[lower], array[upper], upper - lower )) return -1;  

  int mid = (upper + lower) / 2;                                                 

  if(array[mid] == k) return mid;                                                

  lower = find(k, array, lower + abs(k - array[lower]), mid - abs(k - array[mid]));
  if(lower >= 0 ) return lower;                                                    

  upper = find(k, array, mid + abs(k - array[mid]), upper - abs(k - array[upper]));
  if(upper >= 0 ) return upper;                                                  

  return -1;                                                                     

}

const findMeAnElementsFunkyArray = (arr, ele, i) => {
  const elementAtCurrentIndex = arr[i];

  const differenceBetweenEleAndEleAtIndex = Math.abs(
    ele - elementAtCurrentIndex
  );

  const hop = i + differenceBetweenEleAndEleAtIndex;

  if (i >= arr.length) {
    return;
  }
  if (arr[i] === ele) {
    return i;
  }

  const result = findMeAnElementsFunkyArray(arr, ele, hop);

  return result;
};

const array = [4,5,6,5,4,3,2,3,4,5,6,7,8];

const answer = findMeAnElementsFunkyArray(array, 7, 0);

console.log(answer);

Soruna özyinelemeli bir çözüm eklemek istedi. Zevk almak