web-dev-qa-db-de.com

C++ Berechnen des Modus eines sortierten Arrays

Ich muss einen C++ - Code schreiben, der den Median und den Modus eines Arrays ermittelt. Mir wurde gesagt, dass es viel einfacher ist, den Modus eines Arrays zu finden, nachdem die Zahlen sortiert wurden. Ich habe die Funktion sortiert, kann den Modus aber immer noch nicht finden. 

 int counter = 0;
    for (int pass = 0; pass < size - 1; pass++)
        for (int count = pass + 1; count < size; count++) {
            if (array [count] == array [pass])
                counter++;
            cout << "The mode is: " << counter << endl;
c++arraysmodesorted
5
John

Wenn das Array bereits sortiert wurde, können Sie das Vorkommen einer Nummer gleichzeitig zählen. Dann speichern Sie einfach die Nummer mit den größten Vorkommen. Und Sie können den Modus nur in einer for-Schleife herausfinden. Andernfalls müssen Sie mehr als eine for-Schleife ausführen. Ein Beispiel finden Sie unter dem Link unter . .] Finden Sie den Modus einer Anzahl von Zahlen

Hier ist der Code,

int number = array[0];
int mode = number;
int count = 1;
int countMode = 1;

for (int i=1; i<size; i++)
{
      if (array[i] == number) 
      { // count occurrences of the current number
         ++count;
      }
      else
      { // now this is a different number
            if (count > countMode) 
            {
                  countMode = count; // mode is the biggest ocurrences
                  mode = number;
            }
           count = 1; // reset count for the new number
           number = array[i];
  }
}

cout << "mode : " << mode << endl;
5
Deidrei

Eine Möglichkeit ist, dass Sie Lauflängencodierung verwenden können. Bei der Lauflängencodierung würde die Darstellung folgendermaßen aussehen. (Element, seine Häufigkeit).

Behalten Sie dabei die maximale Häufigkeit und das Element im Auge. Dadurch erhalten Sie den Modus, sobald Sie die Lauflänge abgeschlossen haben.

zum Beispiel:

 1 1  2 2 2 3 3 4 5

Es wäre Lauflängencodierung

 {1, 2}, {2, 3}, {3, 2}, {4, 1}, {5, 1}

Es benötigt O(n) Platz.

2
doptimusprime

So habe ich es gemacht, meine Lösung verwendet einen sortierten Vektor als Eingabe. Es hat O(n) Zeitkomplexität und kann mit dem Fall arbeiten, in dem sich mehr als 1 "Modus" -Nummer im Vektor befindet.

void findMode(vector<double> data) {

double biggestMode = 1;
vector<double> mode, numbers;
numbers.Push_back(data.at(0));
mode.Push_back(1);
int count = 0;
for (int i = 1; i < data.size(); i++) {
    if (data.at(i) == numbers.at(count)) {
        mode.at(count)++;
    }
    else {
        if (biggestMode < mode.at(count)) {
            biggestMode = mode.at(count);
        }
        count++;
        mode.Push_back(1);
        numbers.Push_back(data.at(i));
    }
}

for (int i = 0; i < mode.size(); i++) {
    if (mode.at(i) == biggestMode)
        cout << numbers.at(i) << " ";
}
cout << endl;

}

1
Anh Nguyen

Hier ist das Code-Snippet:

int number = array[0];
int mode = number;
int count = 1;
int countMode = 1;

for (int i=1; i<size; i++)
{
    if (array[i] == number) 
    {
        count++;
    }
    else
    {
        if (count > countMode) 
        {
            countMode = count;
            mode = number;
        }
        count = 1;
        number = array[i];
    }
}

cout << "mode : " << mode << endl;
1
Aseem Raj Baranwal

Während Diedreys Antwort nah ist, haben einige Leute auf einige Mängel hingewiesen, beispielsweise ob der Modus durch die letzten Zahlen des sortierten Arrays definiert ist (1,2,3,3,4,4,4 würde 3 als Modus zurückgeben). Abhängig von den Anforderungen an den Umgang mit mehreren Modi gibt es auch unterschiedliche Lösungen.

Diese Lösung führt mehrere Dinge aus:

  1. Behebt das Problem, dass sich der Modus am Ende des Arrays befindet
  2. Wenn es mehrere Modi gibt (mehr als eine Zahl hat die gleiche Anzahl von Vorkommen mit einer Zählung> 1), wird die kleinste Zahl als der Modus zurückgegeben
  3. Kehrt zurück -1 wenn es keinen Modus gibt (jede Zahl kommt nur einmal vor)
int number = array[0];
int mode = number;
int count = 1;
int countMode = 1;

for (int i=1; i<size; i++)
{
      if (array[i] == number) 
      { // increment the count of occurrences for the current number
         ++count;
         if (count > countMode) 
         {
               countMode = count; // this number now has the most occurrences 
               mode = number; // this number is now the mode
         }
      }
      else
      { // now this is a different number
           count = 1; // reset count for the new number
           number = array[i]; // set the new number
  }
}
if (countMode == 1) {
  mode = -1; // set the mode to -1 if each number in the array occur only once
}

cout << "mode : " << mode << endl;
0
STLxZEROx

Der "Modus" ist der am häufigsten vorkommende Wert. Wenn keine Nummer wiederholt wird, gibt es keinen Modus für die Liste. Die Sortierung wäre also nicht von Vorteil, wenn Sie den "Modus" kennen müssen.

Sind Sie sicher, dass Sie sich nicht auf den Median beziehen? Der Median ist die mittlere Zahl in einer Menge. Wenn Sie 1,2,3,4,5 haben, ist der Median (mittlere Zahl) die (total_number)/2) gerundet, wenn er ungerade ist, 2,5. > 3 und unser Medianwert ist 3. Sie können den Medianwert wirklich nur berechnen, wenn Ihre Zahlen sortiert sind. Wenn Sie eine gerade Zahl in einer Menge 1,2,3,4,5,6 Ihr Modus ist Slots 3,4 (zufällig auch 3,4) (total_number)/2 Slot und (total_number)/2 + 1 Slot für ein beliebiges gerades Zahlenfeld.

http://www.purplemath.com/modules/meanmode.htm

0
Harlow44

Das hatte funktioniert.

int vals[9];                
sort(vals, vals + 9);
int key = vals[0], value = 1,max_key=0,max_value=0;

for (int l = 1; l < 9; l++){
    if (key == vals[l]){
        value++;
    }
    else{
        if (value>max_value){
            max_key = vals[l-1];
            max_value = value;
        }
        key = vals[l];
        value = 1;
    }
}
cout<< "Mode: "<< max_key << endl;
0
Kolitha Warnakulasooriya

Ich habe es so gemacht:

    int main()
{ 
    int mode,modecount2,modecount1;
    bool is_nomode=false;
    vector<int> numbers = { 15,43,25,25,25,25,16,14,93,93,58,14,55,55,55,64,14,43,14,25,15,56,78,13,15,29,14,14,16 };
    sort(numbers);

    //If you uncomment the following part, you can see the sorted list of above numbers
    //for (int i = 0; i < numbers.size(); ++i) std::cout << numbers[i] << '\n';
    //keep_window_open();

    mode = numbers[0];
    modecount1 = 0;
    modecount2 = 1; //Obviously any number exists at least once!
    for (int i = 1; i < numbers.size(); ++i) {
        if(numbers[i]==numbers[i-1]) ++modecount2;
        else {
            if (modecount2 > modecount1) {
                mode = numbers[i - 1];
                modecount1 = modecount2;
            }
            else if (i != 1 && modecount2 == modecount1) { std::cout << "No mode!\n"; is_nomode = true; break; }
            modecount2 = 1;
        }
    }
    if(!is_nomode) std::cout << "Mode of these numbers is: " << mode << std::endl;
    keep_window_open();

Sie können auch weitere 25 zur Liste der Nummern hinzufügen und sehen, was passiert, wenn zwei Nummern das gleiche Vorkommen haben! Ich hoffe, es hilft.

0
M-J

Es gibt ein altes Sprichwort, das besagt "Wenn Sie 10 Programmierer in einen Raum bringen und ihnen das gleiche Programm zum Code geben, werden Sie 12 unterschiedliche Ergebnisse erhalten", daher meine Version der Beantwortung Ihrer Frage. Es ist vielleicht nicht so schnell (ich habe vor, die Geschwindigkeit gegenüber einigen anderen Vorschlägen zu testen), aber ich glaube, es ist leicht zu verstehen.

#include <iostream>

using namespace std;

int main ()
{
    short z[10];
    short maxCount = 0, curCount = 0, cur = 0, most = 0;

    for (int i = 0; i < 10; i++)
        {
         cout << "Enter a number: " << endl;
         cin >> z[i];
        }

    for (int i = 0; i < 10; i++)
        {
         cur = z[i];
            for (int a = i; a < 10; a++)
                {
                 if (cur == z[a])
                    {
                     curCount++;
                     cur = z[a];
                    }
                if (curCount > maxCount)
                   {
                    maxCount = curCount;
                    most = z[a];
                   }
            }
            curCount = 0;
        }

    cout << "the mode is : " << maxCount << ", the number is: " << most << endl;
}
0
Scott A

Dieser Code findet den Modus in C++:

#include <iostream>
using namespace std;

int main(int argc, char** argv)
{
    int i,j,k=0,n,repeat_max=0,cn=0;
    int array1[50],mode[50],count[50]={0},c[50];

    cout<<"\n inter count:\t";
    cin>>n; 


    cout<<"\n";

    for(i=0;i<n;i++)
    cin>>array1[i];

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

            if(array1[i]==array1[j])
            {   
                count[i]++;
                if(count[i]>=repeat_max)
                {
                    repeat_max=count[i];
                    mode[k++]=array1[i];        
                }
            }
        }
    }
    cout<<"\n================\n";
    for(i=1;i<k;i++)
    cout<<"\t mode[i]="<<mode[i]<<"\n";
    cout<<"\t\n\nrepeat array:"<<repeat_max;

    return 0;
}
0
ali
int number = array[0];
int mode = number;
int count = 1;
int countMode = 1;

for (int i=1; i<size; i++)
{
  if (array[i] == number) 
  { // count occurrences of the current number
     ++count;
  }
  else
  { // now this is a different number

       count = 1; // reset count for the new number
       number = array[i];
  }
  if (count > countMode) {
              countMode = count;
              mode = number;
  }
}

cout << "mode : " << mode << endl;
0
Parmar Kamlesh

Dieser Code sollte Ihnen den Modus geben. Wenn es zwei gleiche Zahlen gibt, wird die erste Zahl ausgegeben.

int count = 1, mode = 0, m = 0, i = 1;
size_t sz = sizeof(array)/sizeof(*array);
while(i != sz+1) {
    if(array[i-1] != array[i]) {
        if(count > m) {
            mode = array[i-1];
            m = count;
            count = 1;
        }
    }
    else
        ++count;
    ++i;
}
std::cout << "mode: " << mode << std::endl;
0
Ares

Dieser Code verwendet "map", um den MODE aus dem angegebenen Array herauszufinden. Es wird davon ausgegangen, dass das Array bereits sortiert ist.

int findMode(int * arr, int arraySize)
{
    map<int, int> modeMap;
    for (int i = 0; i < arraySize; ++i) {
        ++modeMap[arr[i]];
    }

    auto x = std::max_element(modeMap.begin(), modeMap.end(),
        [](const pair<int, int>& a, const pair<int, int>& b) {
        return a.second < b.second; });

    return x->first;
}
0
oya163