Array und bubblesort um ein Element erweitern

[Hans (Gast)]

Guten Tag,

ich will einen bubblesort Algorithmus um ein Element erweitern. (arduino 
IDE)

Reicht es wenn ich

for (uint8_t e = 0; e < 2; e++) {

in

for (uint8_t e = 0; e < 3; e++) {

ändere?
Es scheint zu funktionieren,aber mir ist nicht ganz klar warum bzw ob 
Fehler auftauchen können.

#define ARRAYTIEFE 2
-> neu #define ARRAYTIEFE 3
#define TYPE_ID 0
#define TYPE_STATE 1
-> soll dazukommen #define TYPE_INDEX 2
#define NUM_OF_MAX_SENSORS 10
byte sensor_AND_1[ARRAYTIEFE][NUM_OF_MAX_SENSORS] = { { 0 }, { 0 } }; 
-> neu byte sensor_AND_1[ARRAYTIEFE][NUM_OF_MAX_SENSORS] = { { 0 }, { 0 }, { 0 } }; 



for (uint8_t c = 0; c < NUM_OF_MAX_SENSORS - 1; c++) { // do a bubble sort
    for (uint8_t d = 0; d < NUM_OF_MAX_SENSORS - c - 1; d++) {
      if (sensor_AND_1[TYPE_ID][d] > sensor_AND_1[TYPE_ID][d + 1]) { // compare
        for (uint8_t e = 0; e < 2; e++) {  // swap both id & state
          int tempval = sensor_AND_1[e][d];
          sensor_AND_1[e][d] = sensor_AND_1[e][d + 1];
          sensor_AND_1[e][d + 1] = tempval;
        }
      }
    }
  }

[Hans (Gast)]

Eine zusätzliche Frage..könnte man das Array sensor_AND_1 in der 
Funktion auch variabel machen, damit ich die ganze Sortiererei in eine 
eigen Funktion packen kann? zb

void sortieren(byte array){
..
}

um damit verschiedene Arrays zu sortieren?

sortieren(sensor_AND_1);
sortieren(sensor_AND_2);

[A. S. (Gast)]

Geht alles, … irgendwie. Zumindest wenn klar ist, was gemacht werden 
soll.

Warum läuft e bis 2 und nicht bis zum zugehörigen #define?

[Hans (Gast)]

Hallo.
da gab es keinen speziellen Grund, im aktuellen Code ist das jetzt 
übernommen

Also ich möchte das 3D Array sensor_AND_1 an eine Funktion übergeben. 
Mir ist diese Übergabe nicht klar

[Nick M. (Gast)]

Hans schrieb:

> for (uint8_t e = 0; e < 2; e++) {  // swap both id & state
>           int tempval = sensor_AND_1[e][d];
>           sensor_AND_1[e][d] = sensor_AND_1[e][d + 1];
>           sensor_AND_1[e][d + 1] = tempval;
>         }

Also wenn ich mir das anschaue, dann kommt mir dein 2D-array schon 
grundlegend verkorkst vor.

Du schreibst im Kommentar "swap id & state", dabei änder sich aber der 
Index mit dem Namen "NUM_OF_MAX_SENSORS". Wie passt denn das zusammen? 
Wenn Du 10 Sensoren hast, dann kann doch auf index Ungerade nicht die id 
und auf Index Gerade der Zustand sein.

Bring das mal in Ordnung und verwende structs. Dann kapierst du und 
Andere das auch.

Oder stammt das Konstrukt aus der Arduino-IDE? Das würde einiges 
erklären!

[Nick M. (Gast)]

Hans schrieb:
> Also ich möchte das 3D Array sensor_AND_1

Aha, dachte ich es mir doch. Das ist kein 3D-array. Bring den Mist erst 
mal auf ordentliche Beine und dann mach weiter.

Und danach nimm qsort aus der C-lib her ...

[Hans (Gast)]

Das hilft mir jetzt leider nicht weiter. Ich möchte kein struct 
verwenden, sondern ein mehrdimensionales Array.

Die Sortierung scheint in der jetzigen Version ja zu funkionieren, oder 
sollte es nicht??

for (uint8_t c = 0; c < NUM_OF_MAX_SENSORS - 1; c++) { // do a bubble sort
    for (uint8_t d = 0; d < NUM_OF_MAX_SENSORS - c - 1; d++) {
      if (sensor_AND_1[TYPE_ID][d] > sensor_AND_1[TYPE_ID][d + 1]) { // compare
        for (uint8_t e = 0; e < ARRAYTIEFE; e++) { 
          int tempval = sensor_AND_1[e][d];
          sensor_AND_1[e][d] = sensor_AND_1[e][d + 1];
          sensor_AND_1[e][d + 1] = tempval;
        }
      }
    }
  }

[Nick M. (Gast)]

Hans schrieb:
> Ich möchte kein struct
> verwenden, sondern ein mehrdimensionales Array.

Geh doch mal auf mein Posting von 18:17 ein und versuch das zu erklären 
was du da machst. IMHO ist das falsch.

Und wie viele Dimensionen hat dein Array jetzt? 2 oder 3?

Und du sollts dein mehrdimensionales array durch ein array von structs 
ersetzen, weil das mit deiner id und state ganz offensichtlich in die 
Hose gegangen ist. Der Grund ist, dass du deine Daten nicht ordentlich 
strukturiert hast. Sowas fängt prinzipiell mit einem typedef an (ausser 
den type gibt es schon).

[Hans (Gast)]

Ich habe das Beispiel übernommen, weil ich selbst das nicht hinbekommen 
habe mit mehreren Dimensionen.
Das Array ist so definiert:
byte sensor_AND_1[3][10] = { {0}, {0}, {0} };

Das ist dann wohl ein 2D array. Ich bin da auch nicht so firm in dem 
ganzen und beschäftige mich nicht beruflich damit.

Das wäre das ganze Programm, welches wie gewünscht diese Aussage 
erzeugt:
Es wird nach ID sortiert und alles ID>0 ausgegeben

ID STATE INDEX
10 1 100
11 1 101
12 1 102
14 1 103
15 1 104
16 1 105
17 1 106
0 1 107
0 1 108
13 1 109

10 1 100
11 1 101
12 1 102
13 1 109
14 1 103
15 1 104
16 1 105
17 1 106

#include <Arduino.h>

#define EEPROM_AND1_0 100
#define EEPROM_AND1_1 101
#define EEPROM_AND1_2 102
#define EEPROM_AND1_3 103
#define EEPROM_AND1_4 104
#define EEPROM_AND1_5 105
#define EEPROM_AND1_6 106
#define EEPROM_AND1_7 107
#define EEPROM_AND1_8 108
#define EEPROM_AND1_9 109

#define ARRAYTIEFE 3
#define TYPE_ID 0
#define TYPE_STATE 1
#define TYPE_INDEX 2
#define NUM_OF_MAX_SENSORS 10
byte sensor_AND_1[ARRAYTIEFE][NUM_OF_MAX_SENSORS] = { { 0 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { EEPROM_AND1_0, EEPROM_AND1_1, EEPROM_AND1_2, EEPROM_AND1_3, EEPROM_AND1_4, EEPROM_AND1_5, EEPROM_AND1_6, EEPROM_AND1_7, EEPROM_AND1_8, EEPROM_AND1_9 } };

void setup() {
  Serial.begin(115200);
  Serial.println (__FILE__);

  sensor_AND_1[TYPE_ID][0] = 10;  sensor_AND_1[TYPE_INDEX][0] = EEPROM_AND1_0;
  sensor_AND_1[TYPE_ID][1] = 11;  sensor_AND_1[TYPE_INDEX][1] = EEPROM_AND1_1;
  sensor_AND_1[TYPE_ID][2] = 12;  sensor_AND_1[TYPE_INDEX][2] = EEPROM_AND1_2;
  sensor_AND_1[TYPE_ID][3] = 14;  sensor_AND_1[TYPE_INDEX][3] = EEPROM_AND1_3;
  sensor_AND_1[TYPE_ID][4] = 15;  sensor_AND_1[TYPE_INDEX][4] = EEPROM_AND1_4;
  sensor_AND_1[TYPE_ID][5] = 16;  sensor_AND_1[TYPE_INDEX][5] = EEPROM_AND1_5;
  sensor_AND_1[TYPE_ID][6] = 17;  sensor_AND_1[TYPE_INDEX][6] = EEPROM_AND1_6;
  sensor_AND_1[TYPE_ID][7] = 0;   sensor_AND_1[TYPE_INDEX][7] = EEPROM_AND1_7;
  sensor_AND_1[TYPE_ID][8] = 0;   sensor_AND_1[TYPE_INDEX][8] = EEPROM_AND1_8;
  sensor_AND_1[TYPE_ID][9] = 13;  sensor_AND_1[TYPE_INDEX][9] = EEPROM_AND1_9;


  Serial.println ("ID STATE INDEX");

  for (int i = 0; i < NUM_OF_MAX_SENSORS; i++)
  {
    Serial.print (sensor_AND_1[TYPE_ID][i]); Serial.print (" "); Serial.print (sensor_AND_1[TYPE_STATE][i]); Serial.print (" "); Serial.println(sensor_AND_1[TYPE_INDEX][i]);
  }
  Serial.println();

  for (uint8_t c = 0; c < NUM_OF_MAX_SENSORS - 1; c++) { // do a bubble sort
    for (uint8_t d = 0; d < NUM_OF_MAX_SENSORS - c - 1; d++) {
      if (sensor_AND_1[TYPE_ID][d] > sensor_AND_1[TYPE_ID][d + 1]) { // compare
        for (uint8_t e = 0; e < ARRAYTIEFE; e++) {  // swap both values & index
          int tempval = sensor_AND_1[e][d];
          sensor_AND_1[e][d] = sensor_AND_1[e][d + 1];
          sensor_AND_1[e][d + 1] = tempval;
        }
      }
    }
  }

  for (int i = 0; i < NUM_OF_MAX_SENSORS; i++)  {
    if (sensor_AND_1[TYPE_ID][i] > 0) {
      Serial.print (sensor_AND_1[TYPE_ID][i]); Serial.print (" "); Serial.print (sensor_AND_1[TYPE_STATE][i]); Serial.print (" "); Serial.println(sensor_AND_1[TYPE_INDEX][i]);
    }
  }

}

void loop() {
  // put your main code here, to run repeatedly:

}

[Nick M. (Gast)]

Dann wünsche ich noch viel Erfolg auf dem langen Weg.

[Hans (Gast)]

Super, danke

[Hans (Gast)]

Kennt sich jemand anders damit aus wie man das Array an eine Funktion 
übergibt und dann damit weiter arbeitet?
Ich müsste 3 verschiedene Array sortieren. Jetzt kann ich natürlich 
einfach 3 mal den Sortiercode untereinanderpacken, aber vielleicht ginge 
es ja noch kompakter? Würde mich halt interessieren wie man das 
übergibt, ansonsten lass ich es so, da es wunderbar funktioniert.

[sid (Gast)]

Nuja klar.. du kannst die Sortierschleife(n)
in eine funktion packen (void) und
der den pointer zu dem zu sortierenden Array übergeben,

welches Array du dann übergibst ist dann egal,
solange es passend dimensioniert und formatiert ist zur Sortierschleife 
versteht sich.

'sid

[foobar (Gast)]

> Kennt sich jemand anders damit aus wie man das Array an eine Funktion
> übergibt und dann damit weiter arbeitet?
> Ich müsste 3 verschiedene Array sortieren. Jetzt kann ich natürlich
> einfach 3 mal den Sortiercode untereinanderpacken, aber vielleicht
> ginge es ja noch kompakter?

Du vertauscht erstmal die beiden Indizes (array[type][i] -> 
arry[i][type]).  Als nächstes schaust du dir an, was Structs sind und 
machst aus den "types" eine struct (byte array[i][type] ->  struct foo 
array[i]), und letzendlich schaust du dir die Doku zu qsort an.

[Andreas Rückert (Gast)]

Bei so kleinen Zahlen würd ich da gar nix sortieren. Mach ein Array bis 
zu max ID und schreib da die Nummer vom Sensor rein? Danach einmal 
Schleife übers Array und wieder ausgeben?

[A. S. (Gast)]

Das Problem sind nicht fehlende Experten oder Wille.

Das Problem ist ein völlig verkorksten Beispiel, aus dem nicht klar 
wird, was oder warum Du tust.

Höchstwahrscheinlich sind Arrays hier für Dich zu schwierig, weil bei 
ihnen die Größe nicht mit übergeben wird und die Bezeichnung der 
Bestandteile (Elemente, eher Dimensionen) ... schwierig ist .

Schau Dir deshalb structs an oder erkläre Deine Absicht und finde einen 
Kompromiss bei den Benennungen.

[PittyJ (Gast)]

Hm, du versuchst zu Programmieren, indem du in irgendwelchen 
heruntergeladenen Quellen versuchst, Teile zu modifizieren?
Vielleicht wäre es einfacher, sich erst einmal ein Basisbuch zur 
Programmierung zu besorgen, damit man einzelne Konzepte versteht.

Mehrdimensionale Arrays in C sind immer etwas tricky, insbesondere wenn 
man Teile davon an Funktionen übergeben möchte.
Da du anscheinend auf Arduino programmierst, könntest du auch C++ nehmen 
Array in Klassen packen, und etwas Komplexität reduziert. Dann könnte 
z.B. man Referenzen auf einzelne Zeilen übergeben. Aber auch dafür 
fehlen wohl noch die Basics.

Fang mit einfacheren Sachen an.

[Hans (Gast)]

>Fang mit einfacheren Sachen an.

Ich habe mir halt ein Gerät mit Display gebaut wofür ich es brauchte und 
es läuft ja nun wie gewünscht. Vielleicht nicht die eleganteste und 
minimalste Lösung, aber für die Praxis macht es keinen Unterschied.

Für Arrays habe ich mich entschieden, da ich einfacher auf bestimmte 
Inhalte zugreifen kann. Auch verstehe ich leider nicht mehr wie sich das 
mit typedef, struct und anderen Gebilden verhält. Eine für mich 
verständliche Anleitung konnte ich nicht finden.
Es ist nicht, dass ich es nicht wollte, mir wird es leider einfach nicht 
klar mit dem mir gefundenen Material. Allerdings habe ich mehrere Texte 
gefunden, die Arrays structs vorziehen auf MCU.

>Das Problem ist ein völlig verkorksten Beispiel, aus dem nicht klar

Ich habe doch extra den ganzen Code inkl Ausgabe geteilt.
Was ist denn da nicht klar? Jeder kann es ausführen bei sich und sieht 
was passiert.

qsort möchte ich vermeiden, da meine Arrays nicht groß sind und ich den 
zusätzlichen Speicherplatz sparen möchte, den diese Funktion verbrauchen 
würde. Laut Tests die ich gefunden habe, wäre das zudem bei meiner Größe 
sogar langsamer. Wobei die Geschwindigkeit bei meiner Anwendung jetzt 
keine Rolle spielt, aber der sehr knappe RAM schon.


>indem du in irgendwelchen heruntergeladenen Quellen versuchst, Teile zu 
modifizieren?

Ja in diesem Fall habe ich es als Baustein gesehen

[foobar (Gast)]

> Es ist nicht, dass ich es nicht wollte, mir wird es leider einfach nicht
> klar mit dem mir gefundenen Material. Allerdings habe ich mehrere Texte
> gefunden, die Arrays structs vorziehen auf MCU.

Es geht nicht um array oder struct - das sind zwei verschiedene Dinge, 
die sich ergänzen.

#define NELEM(x) (sizeof(x) / sizeof(*(x)))

struct sensor {
  byte id, state, index;
};

struct sensor sensor_and_1[] = {
   { 10, 1, 100 },
   { 11, 1, 101 },
   { ... },
   ...
};

static void sensor_sort(struct sensor *array, size_t n)
{
  if (n > 1)
    for (size_t i=0; i<n-1; i++)
      for (size_t j=0; j<n-i-1; j++)
        if (array[j].id > array[j+1].id)
        {
          struct sensor t = array[j];
          array[j] = array[j+1];
          array[j+1] = t;
        }
}

  sensor_sort(sensor_and_1, NELEM(sensor_and_1));
  sensor_sort(another_array, NELEM(another_array));
  ...

[Hans (Gast)]

Hallo,

danke ich versuche das mal nachzuvollziehen. Auf den ersten Blick ist 
das für mich sogar nachvollziehbar. Ich werde mal versuchen, ob ich auf 
die einzelnen Elemente zugreifen kann.

Diese ganze typedef-Geschichte sah für mich halt viel komplizierter und 
verwirrender aus als wenn man einfach  schreibt

byte sensor_AND_1[ARRAYTIEFE][NUM_OF_MAX_SENSORS] = { { 0 }, { 0 }, { 0 
} };