Forum: PC-Programmierung Messwerte sortieren


von Diplomand (Gast)


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++.
1
int CSV::Sortieren(void)              //Sortiert Schaltverlusttabelle
2
{  
3
  int i,ii;
4
  double Reihe[VTSize];
5
  for(i=0;i<VTSize;i++) Reihe[i] = i;
6
  
7
  // +++++++++++++++++++++++++++++++
8
9
  bubblesort(Reihe,IGBTDaten.VT_U,sizeof(IGBTDaten.VT_Ion)/sizeof(IGBTDaten.VT_Ion[0]));
10
11
  // +++++++++++++++++++++++++++++++
12
13
14
  for(i=0;i<VTSize;i++) 
15
  {
16
    ii = Reihe[i];
17
    cout << i << "\t" << IGBTDaten.VT_U[ii] << "\t" << Reihe[ii] << endl;
18
  }
19
20
  return 0;
21
}
22
23
void CSV::bubblesort(double Reihe[], double v[], int n) {
24
  int jj,jj1,i,j;
25
26
  for (i = n - 1; i > 0; i--) {
27
    for (j = 0; j < i; j++) {
28
    jj = Reihe[j];
29
    jj1 = Reihe[j+1];
30
      //if (v[j] > v[j + 1] && v[j] != 0 && v[j+1] != 0) {
31
    if (v[jj] > v[jj1] && v[jj] != 0 && v[jj1] != 0) {
32
      swap(Reihe[j],Reihe[j + 1]);
33
      }
34
    }
35
  }
36
}
1
125  500  100  1,34E-02
2
125  500  216  2,26E-02
3
125  500  327  3,10E-02
4
125  500  504  4,82E-02
5
125  700  102  2,90E-02
6
125  700  219  4,60E-02
7
125  700  332  6,30E-02
8
125  500  650  5,80E-02
9
125  500  748  6,58E-02
10
125  600  366  4,50E-02
11
125  500  1460  1,56E-01
12
125  500  1860  2,13E-01
13
125  500  2530  3,43E-01
14
125  600  102  2,00E-02
15
125  600  220  3,30E-02
16
125  600  504  6,30E-02
17
125  600  667  8,50E-02
18
125  600  769  9,80E-02
19
125  600  1000  1,29E-01
20
125  600  1870  2,83E-01
21
125  600  2550  4,60E-01
22
125  700  496  8,00E-02
23
125  700  660  1,15E-01
24
125  700  762  1,32E-01
25
125  700  981  1,74E-01
26
125  700  1840  3,76E-01
27
125  700  2530  5,99E-01

von Tobi H. (tobi-) Benutzerseite


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...

von Karl H. (kbuchegg)


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:
1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4
5
class Datensatz
6
{
7
public:
8
    double Eon;
9
    double T;
10
    double U;
11
    double I;
12
13
    Datensatz( double Eon_, double T_, double U_, double I_ ) {
14
        Eon = Eon_;
15
        T = T_;
16
        U = U_;
17
        I = I_;
18
    }
19
20
    bool operator<( const Datensatz& rhs )
21
    {
22
        // Wann ist dieser Datensatz kleiner als rhs?
23
        if( T < rhs.T )
24
            return true;
25
26
        if( T == rhs.T ) {
27
            if( U < rhs.U )
28
                return true;
29
30
            if( U == rhs.U )
31
                return I < rhs.I;
32
        }
33
34
        return false;
35
    }
36
};
37
38
int main()
39
{
40
    std::vector<Datensatz> Daten;
41
42
    //
43
    // den vector befüllen.
44
    // der Vector wird dabei selbsttätig größer, um
45
    // alle Datensätze aufzunehmen
46
    //
47
    Daten.push_back( Datensatz( 125,  500,  100,  1.34E-2 ) );
48
    Daten.push_back( Datensatz( 125,  500,  216,  2.26E-2 ) );
49
    Daten.push_back( Datensatz( 125,  500,  327,  3.10E-02 ) );
50
    Daten.push_back( Datensatz( 125,  500,  504,  4.82E-02 ) );
51
    Daten.push_back( Datensatz( 125,  700,  102,  2.90E-02 ) );
52
    Daten.push_back( Datensatz( 125,  700,  219,  4.60E-02 ) );
53
    Daten.push_back( Datensatz( 125,  700,  332,  6.30E-02 ) );
54
    Daten.push_back( Datensatz( 125,  500,  650,  5.80E-02 ) );
55
    Daten.push_back( Datensatz( 125,  500,  748,  6.58E-02 ) );
56
    Daten.push_back( Datensatz( 125,  600,  366,  4.50E-02 ) );
57
    Daten.push_back( Datensatz( 125,  500, 1460,  1.56E-01 ) );
58
    Daten.push_back( Datensatz( 125,  500, 1860,  2.13E-01 ) );
59
    Daten.push_back( Datensatz( 125,  500, 2530,  3.43E-01 ) );
60
    Daten.push_back( Datensatz( 125,  600,  102,  2.00E-02 ) );
61
    Daten.push_back( Datensatz( 125,  600,  220,  3.30E-02 ) );
62
    Daten.push_back( Datensatz( 125,  600,  504,  6.30E-02 ) );
63
    Daten.push_back( Datensatz( 125,  600,  667,  8.50E-02 ) );
64
    Daten.push_back( Datensatz( 125,  600,  769,  9.80E-02 ) );
65
    Daten.push_back( Datensatz( 125,  600, 1000,  1.29E-01 ) );
66
    Daten.push_back( Datensatz( 125,  600, 1870,  2.83E-01 ) );
67
    Daten.push_back( Datensatz( 125,  600, 2550,  4.60E-01 ) );
68
    Daten.push_back( Datensatz( 125,  700,  496,  8.00E-02 ) );
69
    Daten.push_back( Datensatz( 125,  700,  660,  1.15E-01 ) );
70
    Daten.push_back( Datensatz( 125,  700,  762,  1.32E-01 ) );
71
    Daten.push_back( Datensatz( 125,  700,  981,  1.74E-01 ) );
72
    Daten.push_back( Datensatz( 125,  700, 1840,  3.76E-01 ) );
73
    Daten.push_back( Datensatz( 125,  700, 2530,  5.99E-01 ) );
74
75
    //
76
    // den vector sortieren lassen
77
    //
78
    std::sort( Daten.begin(), Daten.end() );
79
80
    //
81
    // und ausgeben
82
    //
83
    for( size_t i = 0; i < Daten.size(); ++i )
84
        std::cout << Daten[i].Eon << " " <<
85
                     Daten[i].T << " " <<
86
                     Daten[i].U << " " <<
87
                     Daten[i].I <<
88
                     std::endl;
89
}


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.