Entfernen Sie Duplikate aus dem Array und speichern Sie sie auf einem anderen [Duplikat].

Nov 24 2020

Ich wurde beauftragt, ein Array ohne doppelte Werte aus einem anderen vorhandenen Array zu erstellen. Also habe ich es getan, aber ich möchte wissen, ob es einen anderen besseren Weg gibt, das zu tun.

Beispiel Eingabe / Ausgabe

Input:: 1, 15, 1, 5, 1, 3

Output:: 1, 15, 5, 3

Mein Code

#include <stdio.h>

int main(void) {
  const int ARRAY_SIZE = 5;

  int m[ARRAY_SIZE], p[ARRAY_SIZE];


  for(int i = 0; i < ARRAY_SIZE; i++) {
    printf("Enter number: ");
    scanf("%d",&m[i]);
  }
  // k variable is used to be the new indexing of the array p;
  int k = 0;

  // if it has a duplication dup is changed to 1;
  int dup = 0;
  
  // Loops through the array.
  for(int i =0; i < ARRAY_SIZE; i++) {
    for(int j = i +1; j <ARRAY_SIZE ; j++) {
        if(m[i] == m[j]) {
            dup = 1;
            break;
        }
    }
    if(dup != 1) {
      p[k++] = m[i];
    }
    dup = 0;
  }

  printf("The array without repeated values\n");

  for(int i = 0; i < k; i++) {
    printf("%d\n",p[i]);
  }

  return 0;
}

Ich möchte einige Vorschläge.

Danke im Voraus. :) :)

Antworten

1 TobySpeight Nov 24 2020 at 19:55

Wenn die Eingabe wirklich Kommas zwischen den Zahlen enthält, möchten wir dies hier berücksichtigen:

scanf("%d",&m[i]);

In jedem Fall ist es wichtig, den Rückgabewert von zu überprüfen scanf(), da wir sonst möglicherweise Werte verwenden, die nicht ordnungsgemäß initialisiert wurden.

Es lohnt sich wahrscheinlich, separate Funktionen für die Eingabe, Ausgabe und Verarbeitung zu schreiben und dann eine einfache zu haben main(), die die drei miteinander verbindet.

1 Noname Nov 24 2020 at 18:25

Ein Flag "dup" kann vermieden werden, indem die innere Schleife neu angeordnet wird. Hier ist eine kompakte Version, irgendwie ein bisschen von innen nach außen, damit wir unser Ding p[k++]=direkt vor Ort machen können:

    for (int i = 0; i < ARRAY_SIZE; i++) {

        for (int j = i + 1; m[i] != m[j]; j++) { /*NO! m[i+1] will be illegal */

            if (j == ARRAY_SIZE) {
                p[k++] = m[i];        // copy this one, next "i" please
                break;
            }
        }
    }

Aus Gründen der Klarheit bevorzuge ich dies fast als innere Schleife:


     for (int j = i + 1;; j++) {

          if (j == ARRAY_SIZE) {
              p[k++] = m[i];        // copy this one, next please
              break;
          }
          if (m[i] == m[j])
              break;               // skip, next 
     }

Das ist symmetrischer; Sie können die beiden Ausgangsbedingungen für diese ewige Schleife leicht vergleichen (kein mittlerer Ausdruck).

Es ist wichtig, zuerst zu überprüfen, ob jARRAY_SIZE erreicht wurde, und es erst dann zu verwenden m[j].


Für ein Array wie 120000000...000012ich denke, wäre es schneller, in dem neuen, einzigartigen Array zu suchen ... aber ja, deshalb ist das Sortieren ein nützlicher erster (und Haupt-) Schritt.


Die erste (kompakte) Version ist sogar falsch . m[j]wird für das letzte Element bereits illegal sein.

for (int j = i + 1; m[i] != m[j];...