Recherche de doublons dans le temps O (n) et dans l'espace O (1)

Entrée: étant donné un tableau de n éléments qui contient des éléments de 0 à n-1, avec l'un de ces nombres apparaissant un nombre illimité de fois.

Objectif: trouver ces nombres répétés en O (n) et en n'utilisant que l'espace mémoire constant.

Par exemple, soit n 7 et array {1, 2, 3, 1, 3, 0, 6}, la réponse doit être 1 & 3. J'ai vérifié des questions similaires ici mais les réponses utilisaient des structures de données comme HashSetetc.

Un algorithme efficace pour le même?

Voici ce que j'ai proposé, qui ne nécessite pas le bit de signe supplémentaire:

for i := 0 to n - 1
    while A[A[i]] != A[i] 
        swap(A[i], A[A[i]])
    end while
end for

for i := 0 to n - 1
    if A[i] != i then 
        print A[i]
    end if
end for

La première boucle permute le tableau de sorte que si l'élément xest présent au moins une fois, alors l'une de ces entrées sera à la position A[x].

Notez qu'il peut ne pas sembler O (n) à première vue, mais c'est le cas - bien qu'il ait une boucle imbriquée, il fonctionne toujours dans le O(N)temps. Un échange se produit uniquement s'il existe un itel que A[i] != i, et chaque échange définit au moins un élément tel que A[i] == i, là où ce n'était pas vrai auparavant. Cela signifie que le nombre total de swaps (et donc le nombre total d'exécutions du whilecorps de la boucle) est au maximum N-1.

La deuxième boucle imprime les valeurs de xpour qui A[x]n'est pas égal x- puisque la première boucle garantit que si elle xexiste au moins une fois dans le tableau, l'une de ces instances sera à A[x], cela signifie qu'elle imprime les valeurs xdont ne sont pas présentes dans le tableau.

(Lien Ideone pour que vous puissiez jouer avec)

La réponse brillante de caf imprime chaque nombre qui apparaît k fois dans le tableau k-1 fois. C'est un comportement utile, mais la question demande sans doute que chaque duplicata soit imprimé une seule fois, et il fait allusion à la possibilité de le faire sans faire sauter les limites linéaires temps / espace constant. Cela peut être fait en remplaçant sa deuxième boucle par le pseudocode suivant:

for (i = 0; i < N; ++i) {
    if (A[i] != i && A[A[i]] == A[i]) {
        print A[i];
        A[A[i]] = i;
    }
}

Cela exploite la propriété qu'après l'exécution de la première boucle, si une valeur mapparaît plus d'une fois, alors l'une de ces apparences est garantie d'être dans la bonne position, à savoir A[m]. Si nous faisons attention, nous pouvons utiliser cet emplacement «d'origine» pour stocker des informations indiquant si des doublons ont déjà été imprimés ou non.

Dans la version de caf, lorsque nous avons parcouru le tableau, A[i] != icela impliquait qu'il s'agissait d' A[i]un doublon. Dans ma version, je m'appuie sur un invariant légèrement différent: cela A[i] != i && A[A[i]] == A[i]implique qu'il A[i]s'agit d'un doublon que nous n'avons jamais vu auparavant . (Si vous supprimez la partie "que nous n'avons jamais vu auparavant", le reste peut être vu comme étant impliqué par la vérité de l'invariant de caf et la garantie que tous les doublons ont une copie dans un emplacement d'origine.) Cette propriété tient à le début (après la fin de la première boucle de caf) et je montre ci-dessous qu'elle est maintenue après chaque étape.

Au fur et à mesure que nous parcourons le tableau, le succès A[i] != idu test implique qu'il A[i] pourrait s'agir d' un doublon qui n'a jamais été vu auparavant. Si nous ne l 'avons pas vu auparavant, nous nous attendons à ce que l A[i]' emplacement d 'origine de la personne se dirige vers lui - c'est ce qui est testé par la seconde moitié de la ifcondition. Si tel est le cas, nous l'imprimons et modifions l'emplacement du domicile pour qu'il pointe vers ce premier doublon trouvé, créant un «cycle» en 2 étapes.

Pour voir que cette opération ne modifie pas notre invariant, supposons m = A[i]qu'une position particulière soit isatisfaisante A[i] != i && A[A[i]] == A[i]. Il est évident que le changement que nous faisons ( A[A[i]] = i) travaillera pour éviter que d' autres événements non domestiques de md'être sortie comme des doublons en provoquant la 2ème moitié de leurs ifconditions à l' échec, mais il lorsqu'il iarrive à l'endroit de la maison, m? Oui, car maintenant, même si à ce nouveau inous constatons que la première moitié de la ifcondition A[i] != iest vraie, la deuxième moitié teste si l'emplacement vers lequel elle pointe est un emplacement d'origine et constate que ce n'est pas le cas. Dans cette situation, nous ne savons plus si mou A[m]était la valeur en double, mais nous savons que de toute façon,cela a déjà été signalé , car ces 2 cycles sont garantis de ne pas apparaître dans le résultat de la 1ère boucle de caf. (Notez que si m != A[m]alors exactement l'un des met A[m]se produit plus d'une fois, et l'autre ne se produit pas du tout.)

Voici le pseudocode

for i <- 0 to n-1:
   if (A[abs(A[i])]) >= 0 :
       (A[abs(A[i])]) = -(A[abs(A[i])])
   else
      print i
end for

Exemple de code en C ++

Pour un N relativement petit, nous pouvons utiliser des opérations div / mod

n.times do |i|
  e = a[i]%n
  a[e] += n
end

n.times do |i| 
  count = a[i]/n
  puts i if count > 1
end

Pas C / C ++ mais de toute façon

http://ideone.com/GRZPI

Pas vraiment joli mais au moins il est facile de voir les propriétés O (N) et O (1). Fondamentalement, nous parcourons le tableau et, pour chaque nombre, nous voyons si la position correspondante a été marquée déjà vue une fois (N) ou déjà vue plusieurs fois (N + 1). S'il est signalé déjà vu une fois, nous l'imprimons et le marquons déjà vu plusieurs fois. S'il n'est pas marqué, nous le marquons déjà vu une fois et nous déplaçons la valeur d'origine de l'index correspondant vers la position actuelle (le marquage est une opération destructive).

for (i=0; i<a.length; i++) {
  value = a[i];
  if (value >= N)
    continue;
  if (a[value] == N)  {
    a[value] = N+1; 
    print value;
  } else if (a[value] < N) {
    if (value > i)
      a[i--] = a[value];
    a[value] = N;
  }
}

ou, mieux encore (plus rapide, malgré la double boucle):

for (i=0; i<a.length; i++) {
  value = a[i];
  while (value < N) {
    if (a[value] == N)  {
      a[value] = N+1; 
      print value;
      value = N;
    } else if (a[value] < N) {
      newvalue = value > i ? a[value] : N;
      a[value] = N;
      value = newvalue;
    }
  }
}

Une solution en C est:

#include <stdio.h>

int finddup(int *arr,int len)
{
    int i;
    printf("Duplicate Elements ::");
    for(i = 0; i < len; i++)
    {
        if(arr[abs(arr[i])] > 0)
          arr[abs(arr[i])] = -arr[abs(arr[i])];
        else if(arr[abs(arr[i])] == 0)
        {
             arr[abs(arr[i])] = - len ;
        }
        else
          printf("%d ", abs(arr[i]));
    }

}
int main()
{   
    int arr1[]={0,1,1,2,2,0,2,0,0,5};
    finddup(arr1,sizeof(arr1)/sizeof(arr1[0]));
    return 0;
}

C'est la complexité du temps O (n) et de l'espace O (1).

Supposons que nous présentions ce tableau comme une structure de données de graphe unidirectionnelle - chaque nombre est un sommet et son index dans le tableau pointe vers un autre sommet formant une arête du graphe.

Pour encore plus de simplicité, nous avons des indices de 0 à n-1 et une plage de nombres de 0..n-1. par exemple

   0  1  2  3  4 
 a[3, 2, 4, 3, 1]

0 (3) -> 3 (3) est un cycle.

Réponse: Traversez simplement le tableau en vous basant sur les indices. si a [x] = a [y] alors c'est un cycle et donc dupliquer. Passer à l'index suivant et continuer encore et ainsi de suite jusqu'à la fin d'un tableau. Complexité: temps O (n) et espace O (1).

Un petit code python pour démontrer la méthode de caf ci-dessus:

a = [3, 1, 1, 0, 4, 4, 6] 
n = len(a)
for i in range(0,n):
    if a[ a[i] ] != a[i]: a[a[i]], a[i] = a[i], a[a[i]]
for i in range(0,n):
    if a[i] != i: print( a[i] )

L'algorithme peut être facilement vu dans la fonction C suivante. La récupération du tableau d'origine, bien que non obligatoire, sera possible en prenant chaque entrée modulo n .

void print_repeats(unsigned a[], unsigned n)
{
    unsigned i, _2n = 2*n;
    for(i = 0; i < n; ++i) if(a[a[i] % n] < _2n) a[a[i] % n] += n;
    for(i = 0; i < n; ++i) if(a[i] >= _2n) printf("%u ", i);
    putchar('\n');
}

Ideone Link pour les tests.

static void findrepeat()
{
    int[] arr = new int[7] {0,2,1,0,0,4,4};

    for (int i = 0; i < arr.Length; i++)
    {
        if (i != arr[i])
        {
            if (arr[i] == arr[arr[i]])
            {
                Console.WriteLine(arr[i] + "!!!");
            }

            int t = arr[i];
            arr[i] = arr[arr[i]];
            arr[t] = t;
        }
    }

    for (int j = 0; j < arr.Length; j++)
    {
        Console.Write(arr[j] + " ");
    }
    Console.WriteLine();

    for (int j = 0; j < arr.Length; j++)
    {
        if (j == arr[j])
        {
            arr[j] = 1;
        }
        else
        {
            arr[arr[j]]++;
            arr[j] = 0;
        }
    }

    for (int j = 0; j < arr.Length; j++)
    {
        Console.Write(arr[j] + " ");
    }
    Console.WriteLine();
}

J'ai créé un exemple d'application de jeu dans Swift pour trouver des doublons dans une complexité de temps 0 (n) et un espace supplémentaire constant. Veuillez vérifier l'URL Recherche de doublons

La solution IMP ci- dessus fonctionnait lorsqu'un tableau contient des éléments de 0 à n-1, l'un de ces nombres apparaissant un nombre illimité de fois.

private static void printRepeating(int arr[], int size) {
        int i = 0;
        int j = 1;
        while (i < (size - 1)) {
            if (arr[i] == arr[j]) {
                System.out.println(arr[i] + " repeated at index " + j);
                j = size;
            }
            j++;
            if (j >= (size - 1)) {
                i++;
                j = i + 1;
            }
        }

    }

Si le tableau n'est pas trop grand, cette solution est plus simple, elle crée un autre tableau de même taille pour le cocher.

1 Créez un bitmap / tableau de même taille que votre tableau d'entrée

 int check_list[SIZE_OF_INPUT];
 for(n elements in checklist)
     check_list[i]=0;    //initialize to zero

2 scannez votre tableau d'entrée et incrémentez son nombre dans le tableau ci-dessus

for(i=0;i<n;i++) // every element in input array
{
  check_list[a[i]]++; //increment its count  
}  

3 Maintenant, scannez le tableau check_list et imprimez le duplicata une ou autant de fois qu'ils ont été dupliqués

for(i=0;i<n;i++)
{

    if(check_list[i]>1) // appeared as duplicate
    {
        printf(" ",i);  
    }
}

Bien sûr, cela prend deux fois l'espace consommé par la solution donnée ci-dessus, mais l'efficacité en temps est O (2n) qui est fondamentalement O (n).