www.mikrocontroller.net

Forum: PC-Programmierung Messwerte sortieren


Autor: Diplomand (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe einen Datensatz von Messwerten für Schaltenergien.
Eon -> f(U,I,T)
Jetzt möchte ich diesen Datensatz nach T, dann nach U und dann nach I 
sortieren. Nach einer Spalte bekomme ichs ja sortiert. Aber wie mache 
ich das nach mehreren Spalten.
Ich programmiere in c++.
int CSV::Sortieren(void)              //Sortiert Schaltverlusttabelle
{  
  int i,ii;
  double Reihe[VTSize];
  for(i=0;i<VTSize;i++) Reihe[i] = i;
  
  // +++++++++++++++++++++++++++++++

  bubblesort(Reihe,IGBTDaten.VT_U,sizeof(IGBTDaten.VT_Ion)/sizeof(IGBTDaten.VT_Ion[0]));

  // +++++++++++++++++++++++++++++++


  for(i=0;i<VTSize;i++) 
  {
    ii = Reihe[i];
    cout << i << "\t" << IGBTDaten.VT_U[ii] << "\t" << Reihe[ii] << endl;
  }

  return 0;
}

void CSV::bubblesort(double Reihe[], double v[], int n) {
  int jj,jj1,i,j;

  for (i = n - 1; i > 0; i--) {
    for (j = 0; j < i; j++) {
    jj = Reihe[j];
    jj1 = Reihe[j+1];
      //if (v[j] > v[j + 1] && v[j] != 0 && v[j+1] != 0) {
    if (v[jj] > v[jj1] && v[jj] != 0 && v[jj1] != 0) {
      swap(Reihe[j],Reihe[j + 1]);
      }
    }
  }
}

125  500  100  1,34E-02
125  500  216  2,26E-02
125  500  327  3,10E-02
125  500  504  4,82E-02
125  700  102  2,90E-02
125  700  219  4,60E-02
125  700  332  6,30E-02
125  500  650  5,80E-02
125  500  748  6,58E-02
125  600  366  4,50E-02
125  500  1460  1,56E-01
125  500  1860  2,13E-01
125  500  2530  3,43E-01
125  600  102  2,00E-02
125  600  220  3,30E-02
125  600  504  6,30E-02
125  600  667  8,50E-02
125  600  769  9,80E-02
125  600  1000  1,29E-01
125  600  1870  2,83E-01
125  600  2550  4,60E-01
125  700  496  8,00E-02
125  700  660  1,15E-01
125  700  762  1,32E-01
125  700  981  1,74E-01
125  700  1840  3,76E-01
125  700  2530  5,99E-01

Autor: Tobi H. (tobi-) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die Vergleichsfunktion kann man entsprechend anpassen (gilt für alle 
Sortierverfahren):
- wenn x1 > y1 -> tauschen
- wenn x1 == y1 -> wenn x2 > y2 -> tausche
- wenn x1 == y1 -> wenn x2 == y2 -> wenn x3 > y3 -> tausche
usw...

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Ich programmiere in c++.

Wenn du wirklich C++ programmieren würdest, würdest du nicht
selbst ein Sortierverfahren aufsetzen (noch dazu Bubble Sort)
sondern ganz einfach std::sort benutzen.

Du beginnst mal damit, dass du dir eine Klasse oder eine
Struct für eine Zeile deiner 'Tabelle' definierst

class Datensatz {
  public:
    double T;
    double U;
    double I;
};

das standard Sortierverfahren findet sich im Header algorithm.
Die einfachste Möglichkeit ist es, wenn ein Objekt selbst weiss,
was es heist kleiner als ein anderes Objekt derselben Klasse zu
sein.
In deinem Fall:
wenn T kleiner als das andere T ist, dann ist das Objekt
auf jeden Fall kleiner.
Ist T größer als das andere T, dann ist das Objekt auf
jeden Fall größer.
Nur wenn beide T gleich sind, erhebt sich die Frage, wer
kommt zuerst. Dann wird U benutzt um das zu entscheiden:
Ist das U kleiner als Das U vom anderen Objekt, dann ist
dieses Objekt kleiner, etc.

Geht man diese Strategie, dass ein Objekt selbst wissen
soll, wann es kleiner als ein anderes Objekt ist, dann
heist das das man sich einen operator< definiert, der
genau diese Strategie ausdrückt.

Du kannst einen std::vector als Datenspeicher benutzen, aber
auch ein Array, gebildet aus Datensatz-Einträgen.

Da du was lernen sollst, nehme ich mal std::vector:

#include <iostream>
#include <vector>
#include <algorithm>

class Datensatz
{
public:
    double Eon;
    double T;
    double U;
    double I;

    Datensatz( double Eon_, double T_, double U_, double I_ ) {
        Eon = Eon_;
        T = T_;
        U = U_;
        I = I_;
    }

    bool operator<( const Datensatz& rhs )
    {
        // Wann ist dieser Datensatz kleiner als rhs?
        if( T < rhs.T )
            return true;

        if( T == rhs.T ) {
            if( U < rhs.U )
                return true;

            if( U == rhs.U )
                return I < rhs.I;
        }

        return false;
    }
};

int main()
{
    std::vector<Datensatz> Daten;

    //
    // den vector befüllen.
    // der Vector wird dabei selbsttätig größer, um
    // alle Datensätze aufzunehmen
    //
    Daten.push_back( Datensatz( 125,  500,  100,  1.34E-2 ) );
    Daten.push_back( Datensatz( 125,  500,  216,  2.26E-2 ) );
    Daten.push_back( Datensatz( 125,  500,  327,  3.10E-02 ) );
    Daten.push_back( Datensatz( 125,  500,  504,  4.82E-02 ) );
    Daten.push_back( Datensatz( 125,  700,  102,  2.90E-02 ) );
    Daten.push_back( Datensatz( 125,  700,  219,  4.60E-02 ) );
    Daten.push_back( Datensatz( 125,  700,  332,  6.30E-02 ) );
    Daten.push_back( Datensatz( 125,  500,  650,  5.80E-02 ) );
    Daten.push_back( Datensatz( 125,  500,  748,  6.58E-02 ) );
    Daten.push_back( Datensatz( 125,  600,  366,  4.50E-02 ) );
    Daten.push_back( Datensatz( 125,  500, 1460,  1.56E-01 ) );
    Daten.push_back( Datensatz( 125,  500, 1860,  2.13E-01 ) );
    Daten.push_back( Datensatz( 125,  500, 2530,  3.43E-01 ) );
    Daten.push_back( Datensatz( 125,  600,  102,  2.00E-02 ) );
    Daten.push_back( Datensatz( 125,  600,  220,  3.30E-02 ) );
    Daten.push_back( Datensatz( 125,  600,  504,  6.30E-02 ) );
    Daten.push_back( Datensatz( 125,  600,  667,  8.50E-02 ) );
    Daten.push_back( Datensatz( 125,  600,  769,  9.80E-02 ) );
    Daten.push_back( Datensatz( 125,  600, 1000,  1.29E-01 ) );
    Daten.push_back( Datensatz( 125,  600, 1870,  2.83E-01 ) );
    Daten.push_back( Datensatz( 125,  600, 2550,  4.60E-01 ) );
    Daten.push_back( Datensatz( 125,  700,  496,  8.00E-02 ) );
    Daten.push_back( Datensatz( 125,  700,  660,  1.15E-01 ) );
    Daten.push_back( Datensatz( 125,  700,  762,  1.32E-01 ) );
    Daten.push_back( Datensatz( 125,  700,  981,  1.74E-01 ) );
    Daten.push_back( Datensatz( 125,  700, 1840,  3.76E-01 ) );
    Daten.push_back( Datensatz( 125,  700, 2530,  5.99E-01 ) );

    //
    // den vector sortieren lassen
    //
    std::sort( Daten.begin(), Daten.end() );

    //
    // und ausgeben
    //
    for( size_t i = 0; i < Daten.size(); ++i )
        std::cout << Daten[i].Eon << " " <<
                     Daten[i].T << " " <<
                     Daten[i].U << " " <<
                     Daten[i].I <<
                     std::endl;
}



Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.