Array entfernen Sie doppelte Elemente

Überprüfen Sie jedes element gegen jedes andere element

Die naive Lösung ist es zu prüfen jedes element gegen jedes andere element. Dies ist verschwenderisch und gibt einen O(n²) Lösung, auch wenn Sie nur "vorwärts".

Art dann entfernen Sie Duplikate

Eine bessere Lösung ist die Sortierung des Arrays und überprüfen Sie dann jedes element mit der nächsten zu, um Duplikate zu finden. Wählen Sie eine effiziente Art und das ist O(n log n).

Den Nachteil, mit der Art-basierten Lösung ist, um nicht beibehalten werden. Ein zusätzlicher Schritt, der aufpassen kann, dies jedoch. Setzen Sie alle Einträge (in die einzigartige sortierten array) in eine Hashtabelle, die O(1) zugreifen. Dann Durchlaufen Sie das original-array. Für jedes element prüfen, ob es in der hash-Tabelle. Wenn es ist, fügen Sie es in das Ergebnis und Sie löschen es aus der hash-Tabelle. Sie werden am Ende mit einem resultierenden array mit der Reihenfolge der ursprünglichen mit jedem element in der gleichen position wie das erste vorkommen.

Lineare Arten von Ganzzahlen

Wenn man sich mit Ganzzahlen, die von einigen festen Bereich, die Sie tun können noch besser durch die Verwendung einer radix-sort. Wenn Sie davon ausgehen, die zahlen sind alle im Bereich von 0 bis 1.000.000 zum Beispiel, können Sie zuweisen, ein bit-Vektor, der einige 1,000,001. Für jedes element im ursprünglichen array ausgeführt wurde, setzen Sie das entsprechende bit basierend auf seinen Wert (z.B. den Wert 13 Ergebnisse in Einstellung 14 bit). Dann durchqueren Sie das original-array, wenn es in der bit-Vektor. Wenn es ist, fügen Sie es in das Ergebnis-array und klar, dass der bit aus dem bit-Vektor. Das ist O(n) und trades Raum für Zeit.

Hash-Tabelle-Lösung

Das führt uns zu der besten Lösung von allen: die Art ist eigentlich eine Ablenkung, aber nützlich. Erstellen Sie eine Hashtabelle mit O(1) zugreifen. Durchqueren Sie den ursprünglichen Liste. Wenn es nicht in der hashtable schon, fügen Sie es in das Ergebnis-array und fügen Sie es in die hash-Tabelle. Wenn es in der hash-Tabelle, ignorieren Sie es.

Dies ist mit Abstand die beste Lösung. Also warum den rest? Denn Probleme wie diese sind über das anpassen von wissen, das Sie haben (oder sollten haben) zu Problemen und verfeinert, basierend auf den Annahmen, die Sie machen in einer Lösung. Das entwickeln einer Lösung und das Verständnis der Hintergründe ist es weit mehr nützlich, als das wiederkäuen einer Lösung.

Auch, hash-Tabellen sind nicht immer verfügbar. Nehmen Sie ein embedded-system oder etwas, wo der Raum SEHR begrenzt ist. Realisieren Sie eine schnelle Sortierung in einer Handvoll Maschinenbefehle, weit weniger als jede hash-Tabelle sein könnte.

InformationsquelleAutor cletus

Wenn Sie nicht brauchen, um die original-Objekts können Sie mit einer Schleife und erstelle ein neues array mit eindeutigen Werten. In C# eine Liste verwenden, erhalten Sie Zugriff auf die benötigte Funktionalität. Es ist nicht das attraktivste oder intelligente Lösung, aber es funktioniert.

int[] numbers = new int[] {1,2,3,4,5,1,2,2,2,3,4,5,5,5,5,4,3,2,3,4,5};
List<int> unique = new List<int>();

foreach (int i in numbers)
     if (!unique.Contains(i))
          unique.Add(i);

unique.Sort();
numbers = unique.ToArray();

InformationsquelleAutor WDuffy

    indexOutput = 1;
    outputArray[0] = arrayInt[0];
    int j;
    for (int i = 1; i < arrayInt.length; i++) {            
        j = 0;
        while ((outputArray[j] != arrayInt[i]) && j < indexOutput) {
            j++;
        }
        if(j == indexOutput){
           outputArray[indexOutput] = arrayInt[i];
           indexOutput++;
        }         
    }

InformationsquelleAutor dhayyati

Ich Stimme mit Cletus. Verwenden Sie eine QuickSort dann entfernen dups

InformationsquelleAutor Laramie

Meine Lösung(O(N)) nicht nutzen, zusätzliche Speicher, aber das array muss sortiert wurden(meine Klasse, die mit insertion-sort-Algorithmus, aber es spielt keine Rolle.):

  public class MyArray
        {
            //data arr
            private int[] _arr;
            //field length of my arr
            private int _leght;
            //counter of duplicate
            private int countOfDup = 0;
            //property length of my arr
            public int Length
            {
                get
                {
                    return _leght;
                }
            }

            //constructor
            public MyArray(int n)
            {
                _arr = new int[n];
                _leght = 0;
            }

            //put element into array
            public void Insert(int value)
            {
                _arr[_leght] = value;
                _leght++;
            }

            //Display array
            public void Display()
            {
                for (int i = 0; i < _leght; i++) Console.Out.Write(_arr[i] + " ");
            }

            //Insertion sort for sorting array
            public void InsertSort()
            {
                int t, j;
                for (int i = 1; i < _leght; i++)
                {
                    t = _arr[i];
                    for (j = i; j > 0; )
                    {
                        if (_arr[j - 1] >= t)
                        {
                            _arr[j] = _arr[j - 1];
                            j--;
                        }
                        else break;
                    }
                    _arr[j] = t;
                }
            }

            private void _markDuplicate()
            {
                //mark duplicate Int32.MinValue
                for (int i = 0; i < _leght - 1; i++)
                {
                    if (_arr[i] == _arr[i + 1])
                    {
                        countOfDup++;
                        _arr[i] = Int32.MinValue;
                    }
                }
            }

            //remove duplicates O(N) ~ O(2N) ~ O(N + N)
            public void RemoveDups()
            {
                _markDuplicate();
                if (countOfDup == 0) return; //no duplicate
                int temp = 0;

                for (int i = 0; i < _leght; i++)
                {
                    //if duplicate remember and continue
                    if (_arr[i] == Int32.MinValue) continue;
                    else //else need move 
                    {
                        if (temp != i) _arr[temp] = _arr[i];
                        temp++;
                    }
                }
                _leght -= countOfDup;
            }
        }

Haupt-Und

static void Main(string[] args)
{
     Random r = new Random(DateTime.Now.Millisecond);
     int i = 11;
     MyArray a = new MyArray(i);
     for (int j = 0; j < i; j++)
     {
        a.Insert(r.Next(i - 1));
     }

     a.Display();
     Console.Out.WriteLine();
     a.InsertSort();
     a.Display();
     Console.Out.WriteLine();
     a.RemoveDups();
     a.Display();

    Console.ReadKey();
}

InformationsquelleAutor isxaker

Time O(n) space O(n) 

#include <iostream>
    #include<limits.h>
    using namespace std;
    void fun(int arr[],int size){

        int count=0;
        int has[100]={0};
        for(int i=0;i<size;i++){
            if(!has[arr[i]]){
               arr[count++]=arr[i];
               has[arr[i]]=1;
            }
        }
     for(int i=0;i<count;i++)
       cout<<arr[i]<<" ";
    }

    int main()
    {
        //cout << "Hello World!" << endl;
        int arr[]={4, 8, 4, 1, 1, 2, 9};
        int size=sizeof(arr)/sizeof(arr[0]);
        fun(arr,size);

        return 0;
    }

InformationsquelleAutor rjnitt

Können Sie die "in" und "nicht" - syntax in python, das macht es ziemlich straight forward.

Die Komplexität ist höher als die hashing-Ansatz, obwohl da ein "nicht" ist äquivalent zu einer linearen traversal, um herauszufinden, ob dieser Eintrag vorhanden ist oder nicht.

li = map(int, raw_input().split(","))
a = []
for i in li:
    if i not in a:
        a.append(i)
print a

InformationsquelleAutor Deepak Pathania