Effiziente Möglichkeit, ein Element zu suchen

Kürzlich hatte ich ein Interview, in dem sie mir eine " Suchfrage " stellten.
Die Frage war:

Angenommen, es gibt ein Array von (positiven) Ganzzahlen, von denen jedes Element entweder ist +1oder -1mit seinen benachbarten Elementen verglichen wird.

Beispiel:

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

Suchen Sie nun nach 7seiner Position und geben Sie sie zurück.

Ich gab diese Antwort:

Speichern Sie die Werte in einem temporären Array, sortieren Sie sie und wenden Sie dann die binäre Suche an.

Wenn das Element gefunden wird, geben Sie seine Position im temporären Array zurück.
(Wenn die Zahl zweimal vorkommt, geben Sie ihr erstes Vorkommen zurück.)

Aber sie schienen mit dieser Antwort nicht zufrieden zu sein.

Was ist die richtige Antwort?

Sie können eine lineare Suche mit Schritten durchführen, die häufig größer als 1 sind. Die entscheidende Beobachtung ist, dass, wenn z. B. array[i] == 4und 7 noch nicht erschienen sind, der nächste Kandidat für 7 im Index ist i+3. Verwenden Sie eine while-Schleife, die wiederholt direkt zum nächsten geeigneten Kandidaten führt.

Hier ist eine leicht verallgemeinerte Implementierung. Es findet das erste Auftreten kim Array (vorbehaltlich der Einschränkung + = 1) oder -1wenn es nicht auftritt:

#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;
}

Ausgabe:

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

Ihr Ansatz ist zu kompliziert. Sie müssen nicht jedes Array-Element untersuchen. Der erste Wert ist 4, also 7sind zumindest 7-4 Elemente entfernt, und Sie können diese überspringen.

#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;
}

Programmausgabe:

Steps 4, index 11

Bearbeiten: verbessert nach Kommentaren von @Raphael Miedl und @Martin Zabel.

Eine Variation der herkömmlichen linearen Suche könnte ein guter Weg sein. Lassen Sie uns ein Element auswählen, sagen wir array[i] = 2. Jetzt ist array[i + 1]entweder 1 oder 3 (ungerade), array[i + 2]ist (nur positive ganze Zahlen) 2 oder 4 (gerade Zahl).

Wenn Sie so weitermachen, ist ein Muster zu beobachten - array[i + 2*n]es enthält gerade Zahlen, sodass alle diese Indizes ignoriert werden können.

Das können wir auch sehen

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

Daher i + 5sollte der Index als nächstes überprüft werden, und eine while-Schleife kann verwendet werden, um den nächsten zu überprüfenden Index zu bestimmen, abhängig von dem am Index gefundenen Wert i + 5.

Dies hat zwar Komplexität O(n)(lineare Zeit in Bezug auf asymptotische Komplexität), ist jedoch in praktischer Hinsicht besser als eine normale lineare Suche, da nicht alle Indizes besucht werden.

Offensichtlich wird all dies umgekehrt, wenn array[i](unser Ausgangspunkt) ungerade war.

Der von John Coleman vorgestellte Ansatz ist höchstwahrscheinlich der, auf den der Interviewer gehofft hat.
Wenn Sie bereit sind, etwas komplizierter zu werden, können Sie die erwartete Sprunglänge erhöhen:
Rufen Sie den Zielwert k auf . Beginnen Sie mit dem Wert v des ersten Elements an Position p und nennen Sie die Differenz kv dv mit dem Absolutwert av . Um negative Suchvorgänge zu beschleunigen, werfen Sie einen Blick auf das letzte Element als den anderen Wert u an Position o: Wenn dv × du negativ ist, ist k vorhanden (wenn ein Auftreten von k akzeptabel ist, können Sie den Indexbereich hier wie bei der binären Suche eingrenzen). Wenn av + au größer als die Länge des Arrays ist, fehlt k. (Wenn dv × du Null ist, ist v oder u gleich k.)
Auslassen der Indexgültigkeit: Prüfen Sie die ("nächste") Position, an der die Sequenz mit k in der Mitte zu v zurückkehren könnte : o = p + 2*av.
Wenn dv × du negativ ist, finde k (rekursiv?) Von p + av bis o-au;
Wenn es Null ist, ist u gleich k bei o.
Wenn ich gleich dv und der Wert in der Mitte ist nicht k oder au überschreitet av,
oder Sie scheitern k von p zu finden + av o-au,
lassen p=o; dv=du; av=au;und halten Sondieren.
(Für einen vollständigen Rückblick auf die Texte der 60er Jahre mit Courier anzeigen. Mein "1. 2. Gedanke" war zu verwendeno = p + 2*av - 1, was du gleich dv ausschließt .)

SCHRITT 1

Beginnen Sie mit dem ersten Element und prüfen Sie, ob es 7 ist. Angenommen, es chandelt sich um den Index der aktuellen Position. Also zunächst c = 0.

SCHRITT 2

Wenn es 7 ist, haben Sie den Index gefunden. Es ist c. Wenn Sie das Ende des Arrays erreicht haben, brechen Sie aus.

SCHRITT 3

Wenn dies nicht der Fall ist, müssen 7 mindestens |array[c]-7|Positionen entfernt sein, da Sie nur eine Einheit pro Index hinzufügen können. Fügen |array[c]-7|Sie daher zu Ihrem aktuellen Index c hinzu, und gehen Sie erneut zu SCHRITT 2, um dies zu überprüfen.

Im schlimmsten Fall, wenn es abwechselnd 1 und -1 gibt, kann die Zeitkomplexität O (n) erreichen, aber durchschnittliche Fälle würden schnell geliefert.

Hier gebe ich die Implementierung in Java ...

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;
}

Hier ist eine Lösung im Divide-and-Conquer-Stil. Auf Kosten von (viel) mehr Buchhaltung können wir mehr Elemente überspringen; Anstatt von links nach rechts zu scannen, testen Sie in der Mitte und überspringen Sie in beide Richtungen.

#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);

Wollte eine rekursive Lösung für das Problem enthalten. Genießen