# aus 6 Real Zahlen die höchste und die niedrigste ermitteln



## spunky (17 Juli 2007)

Hallo,

Hab da ein kleines Problem, ich möchte 6 Real Zahlen vergleichen und die höchste / niedrigste Zahl ermitteln. 

Am Ende soll das für eine Windenüberwachung dienen. Also Positionen (umdrehung der einzelnen Winde wird gezählt 6 Winden ingesamt). Die Winden sollen sich annähernd gleich schnell bewegen (Tolereanz 10 Impulse). Das heisst das die schnellste Winde abgestoppt werden soll, bis die langsamste Winde wieder aufgeholt hat.

Meine Lösung gefällt mir da nicht so sehr, aber hier tummeln sich ja ne Menge "schlauer" Köpfe herum.


L (Wert Winde 1)
L (Wert Winde 2) 
> R
L (Wert Winde 1)
spb next2
spa nix2
next2:  t  DBx.DBDx (DB.Real Anzahl Umdrehung + Kennung Winde 1)
spa next
nix2: t  DBx.DBDx (DB.Real Anzahl Umdrehung + Kennung Winde 2)
next:
L (DBx.DBDx)
L (Wert Winde 3)
>R
L (Wert Winde 3)
spb next3
spa nix3
next2:  t  DBx.DBDx (DB.Real Anzahl Umdrehung + Kennung Winde 3)
spa next
nix2: t  DBx.DBDx (DB.Real Anzahl Umdrehung + Kennung Winde 1/2)
next:
usw.
das selbe noch für die kleinste Zahl


ich denk mal ein bissel kompliziert wie ich da ran gehe.

Helft mir da mal mit was Schicken auf die Sprünge.

Danke

CPU 315 2DP Soft Step7 5.4


----------



## borromeus (17 Juli 2007)

Vorher sortieren-> BubbleSort-> dann ersten und letzen nehmen.


----------



## spunky (17 Juli 2007)

ähm was meinste mit "Bubble Sort" ??


----------



## Kai (17 Juli 2007)

http://de.wikipedia.org/wiki/Bubblesort

http://www.sps-forum.de/showthread.php?t=12657

Gruß Kai


----------



## spunky (17 Juli 2007)

erst mal danke !!!

muss ich morgen gleich mal testen.


----------



## Zottel (18 Juli 2007)

Bubblesort funktioniert natürlich, ist aber etwas aufwendig ((6-1)*6=30 Vergleiche) für so eine "kleine" Aufgabe. So geht es einfacher:
max=Wert[1]
min=Wert[1]
for i=2 to 6 do begin
 if Wert_>max then max=Wert
 if Wert<min then min=Wert
end
Wenn man statt der Schleife einzelne Vergleiche programmiert, sieht es ähnlich wie dein AWL aus. Die kürzeste Version entsteht, wenn man es sich zunutze macht, daß der erste Wert im Akku verbleibt:
L #Wert1
L #Wert2
>R
SPB keinTausch1
TAK //tausche Akku1 und 2, also Wert1 wieder im Akku1
keinTausch1: L #Wert3
>R
SPB keinTausch2
TAK 
keinTausch2: L #Wert4
>R
SPB keinTausch3
// usw._


----------



## Kai (18 Juli 2007)

spunky schrieb:


> Hab da ein kleines Problem, ich möchte 6 Real Zahlen vergleichen und die höchste / niedrigste Zahl ermitteln.


 
Hier mal ein kurzes Programmbeispiel mit Bubblesort:


```
// FC100 : Bubblesort
 
// Datenbaustein öffnen
 
      AUF   DB   100
 
 
// Datensatz kopieren
 
      CALL  SFC   20
       SRCBLK :=P#DB100.DBX0.0 BYTE 36
       RET_VAL:=#BLKMOV_RET_VAR
       DSTBLK :=P#DB100.DBX36.0 BYTE 36
 
 
// Bubblesort
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     5
M01:  T     #ZAEHLER_01
 
      L     #ZAEHLER_01
M02:  T     #ZAEHLER_02
 
      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPB   M03
      SPA   M04
M03:  L     DBD [AR1,P#0.0]             // Wert 1
      T     DBD   72                    // Wert 7
 
      L     DBW [AR1,P#4.0]             // Kennung 1
      T     DBW   76                    // Kennung 7
 
      L     DBD [AR1,P#6.0]             // Wert 2
      T     DBD [AR1,P#0.0]             // Wert 1
 
      L     DBW [AR1,P#10.0]            // Kennung 2
      T     DBW [AR1,P#4.0]             // Kennung 1
 
      L     DBD   72                    // Wert 7
      T     DBD [AR1,P#6.0]             // Wert 2
 
      L     DBW   76                    // Kennung 7
      T     DBW [AR1,P#10.0]            // Kennung 2
 
M04:  L     P#6.0                       // Zeiger Wert 1 + 1
      +AR1  
 
      L     #ZAEHLER_02
      LOOP  M02
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     #ZAEHLER_01
      LOOP  M01
```
 
Gruß Kai


----------



## borromeus (18 Juli 2007)

Fast nicht verbesserbar!


----------



## Kai (19 Juli 2007)

borromeus schrieb:


> Fast nicht verbesserbar!


 
Hier noch eine leicht verbesserte Programmversion. :-D 


```
// FC100 : Bubblesort
 
// Datenbaustein öffnen
 
      AUF   DB   100
 
 
// Datensatz kopieren
 
      CALL  SFC   20
       SRCBLK :=P#DB100.DBX0.0 BYTE 36
       RET_VAL:=#BLKMOV_RET_VAR
       DSTBLK :=P#DB100.DBX36.0 BYTE 36
 
 
// Bubblesort
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     5
M01:  T     #ZAEHLER_01
 
      L     #ZAEHLER_01
M02:  T     #ZAEHLER_02
 
      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPB   M03
      SPA   M04
M03:  L     DBD [AR1,P#0.0]             // Wert 1 
      L     DBD [AR1,P#6.0]             // Wert 2  
      T     DBD [AR1,P#0.0]             // Wert 2 => Wert 1
      TAK   
      T     DBD [AR1,P#6.0]             // Wert 1 => Wert 2
 
      L     DBW [AR1,P#4.0]             // Kennung 1
      L     DBW [AR1,P#10.0]            // Kennung 2
      T     DBW [AR1,P#4.0]             // Kennung 2 => Kennung 1
      TAK   
      T     DBW [AR1,P#10.0]            // Kennung 1 => Kennung 2
 
M04:  L     P#6.0                       // Zeiger Wert 1 + 1
      +AR1  
 
      L     #ZAEHLER_02
      LOOP  M02
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     #ZAEHLER_01
      LOOP  M01
```
 
Gruß Kai


----------



## zotos (19 Juli 2007)

```
// FC100 : Bubblesort
 
// Datenbaustein öffnen
 
      AUF   DB   100
 
 
// Datensatz kopieren
 
      CALL  SFC   20
       SRCBLK :=P#DB100.DBX0.0 BYTE 36
       RET_VAL:=#BLKMOV_RET_VAR
       DSTBLK :=P#DB100.DBX36.0 BYTE 36
 
 
// Bubblesort
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     5
M01:  T     #ZAEHLER_01
 
M02:  T     #ZAEHLER_02
 
      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPBN  M04
      L     DBD [AR1,P#0.0]             // Wert 1 
      L     DBD [AR1,P#6.0]             // Wert 2  
      T     DBD [AR1,P#0.0]             // Wert 2 => Wert 1
      TAK   
      T     DBD [AR1,P#6.0]             // Wert 1 => Wert 2
 
      L     DBW [AR1,P#4.0]             // Kennung 1
      L     DBW [AR1,P#10.0]            // Kennung 2
      T     DBW [AR1,P#4.0]             // Kennung 2 => Kennung 1
      TAK   
      T     DBW [AR1,P#10.0]            // Kennung 1 => Kennung 2
 
M04:  L     P#6.0                       // Zeiger Wert 1 + 1
      +AR1  
 
      L     #ZAEHLER_02
      LOOP  M02
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     #ZAEHLER_01
      LOOP  M01
```


----------



## Kai (19 Juli 2007)

Hier noch einmal die Änderung von Zotos an meinem Programmcode: 


```
L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPB   M03
      SPA   M04
```
 

```
L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPBN  M04
```
 
Gruß Kai


----------



## Kai (19 Juli 2007)

Zottel schrieb:


> Bubblesort funktioniert natürlich, ist aber etwas aufwendig ((6-1)*6=30 Vergleiche) für so eine "kleine" Aufgabe.


 
Das ist so nicht ganz richtig. 

Bubblesort benötigt zum Sortieren einer Datenfolge der Länge n folgende Anzahl von Vergleichen:


```
n * (n - 1)
(n - 1) + (n - 2) + ... + 1 = -----------
                                   2
```
 
Bei einer Datenfolge von 6 Zahlen  benötigt Bubblesort also 5 Durchläufe (n - 1) mit insgesamt 15 Vergleichen (n * (n - 1) / 2).

Durchlauf 1 = 6 - 1 = 5 Vergleiche

Durchlauf 2 = 6 - 2 = 4 Vergleiche

Durchlauf 3 = 6 - 3 = 3 Vergleiche

Durchlauf 4 = 6 - 4 = 2 Vergleiche

Durchlauf 5 = 6 - 5 = 1 Vergleich

Summe = 15 Vergleiche 

Gruß Kai


----------



## spunky (19 Juli 2007)

Hallo,

hier mal an alle ein DICKES DANKE !!!

man oh man, geniale sache, genau das was ich gebraucht habe.


----------



## hugo (21 Juli 2007)

schau mal in die open source library von oscat rein dort ist bubble sort und auch array min und array max im source code vorhanden
wenn du forlaufend aus einem array min und max werte benötigst solltest du nicht unbedingt bubble sort anwenden, das ist viel zu aufwendig weil zuviele tauschvorgänge.
um min und max zu ermitteln must du nur einmnal das array durchlaufen und hast das ergebnis.
siehe hierzu die fumktionen array_min und array_max
den source code findest du unter www.oscat.de


----------



## cosmo (15 August 2008)

moin,
von mir auch schon mal ein dickes danke, der algorithmus hat mir auch schon sehr geholfen und stehe grad auch noch in den anfängen, und versuche mich in awl einzuarbeiten, und hab auch bislang nur grob mit pointern zu tun gehabt, aber stimmt es, wenn ich jetzt 7 statt 6 zahlen miteinander vergleichen will, ich nur überall wo 36.0 steht, 40.0 schreiben muss, oder müsste noch mehr geändert werden?


----------



## SPSKILLER (15 August 2008)

Hallo,

folgendes sollte einfacher sein (AWL-Quelle):


```
FUNCTION "SORT_MAX_REAL" : VOID
TITLE =Sortieralgorithmus nach größtem Wert [REAL]
AUTHOR : Micha
FAMILY : SORT
NAME : MAX_REAL
VERSION : 1.2
 
VAR_INPUT
  DB_NR : BLOCK_DB ; 
  ANZ : INT ; 
END_VAR
VAR_TEMP
  tiLC : INT ; //Loopcounter
  tbFertig : BOOL ; 
END_VAR
BEGIN
NETWORK
TITLE =Algorithmus
//
//
      AUF   #DB_NR; 
NEU:  LAR1  P#DBX 0.0; 
      S     #tbFertig; 
      L     #ANZ; 
      DEC   1; 
L1:   T     #tiLC; 
      L     D [AR1,P#0.0]; 
      L     D [AR1,P#4.0]; 
      >=R   ; 
      SPB   KSOR; 
      L     D [AR1,P#0.0]; 
      L     D [AR1,P#4.0]; 
      T     D [AR1,P#0.0]; 
      TAK;
      T     D [AR1,P#4.0]; 
      SET   ; 
      R     #tbFertig; 
KSOR: +AR1  P#4.0; 
      L     #tiLC; 
      LOOP  L1; 
      UN    #tbFertig; 
      SPB   NEU; 
END_FUNCTION
```
 
Es muss noch ein DB, der mindestens die Anzahl der am INT-Eingang angegebenen Real-Werte enthält, verschaltet werden.
Nach Bearbeitung des FCs stehen die 6 Werte sortiert im angegebenen DB.

Ich habe keine Auswertung der Parametrierung reinprogrammiert!
Bei Parametrierfehler (z.B. 8 am INT-Eingang, aber nur 6 Real Werte im DB, oder falscher DB) gibts Bereichslängenfehler, und ggf. CPU-Stopp!

Gruß Micha


----------



## Kai (15 August 2008)

cosmo schrieb:


> stimmt es, wenn ich jetzt 7 statt 6 zahlen miteinander vergleichen will, ich nur überall wo 36.0 steht, 40.0 schreiben muss, oder müsste noch mehr geändert werden?


 
Hier noch mal ein kurzes Programmbeispiel für die Sortierung von 7 REAL-Zahlen mit Bubblesort:


```
// FC100 : Bubblesort
 
// Datensatz kopieren
 
      CALL  SFC   20
       SRCBLK :=[COLOR=red]P#DB100.DBX0.0 BYTE 42[/COLOR]
       RET_VAL:=#BLKMOV_RET_VAR
       DSTBLK :=[COLOR=red]P#DB100.DBX42.0 BYTE 42[/COLOR]
 
// Bubblesort
 
      AUF   DB   100                    // Datenbaustein öffnen
 
      [COLOR=red]L     6[/COLOR]
M01:  T     #ZAEHLER_01
 
      [COLOR=red]L     P#42.0[/COLOR]                      // Zeiger Wert 1
      LAR1  
 
      L     #ZAEHLER_01
M02:  T     #ZAEHLER_02
 
      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPBN  M03
      L     DBD [AR1,P#0.0]             // Wert 1 
      L     DBD [AR1,P#6.0]             // Wert 2  
      T     DBD [AR1,P#0.0]             // Wert 2 => Wert 1
      TAK   
      T     DBD [AR1,P#6.0]             // Wert 1 => Wert 2
 
      L     DBW [AR1,P#4.0]             // Kennung 1
      L     DBW [AR1,P#10.0]            // Kennung 2
      T     DBW [AR1,P#4.0]             // Kennung 2 => Kennung 1
      TAK   
      T     DBW [AR1,P#10.0]            // Kennung 1 => Kennung 2
 
M03:  L     P#6.0                       // Zeiger Wert 1 + 1
      +AR1  
 
      L     #ZAEHLER_02
      LOOP  M02
 
      L     #ZAEHLER_01
      LOOP  M01
```
 
Gruß Kai


----------



## volker (15 August 2008)

ohne jetzt mal auf den sinn einer vorigen sortierung einzugehen nur um min/max zu bestimmen, guckst du mal hier

http://lischis-home.dyndns.org/files/SPS/S7_Bausteine/dirindex.php
dort db_auswerten.zip


----------



## cosmo (18 August 2008)

ja danke schön, ich denk mal damit sollte ich es hinbekommen.
aber der sinn des ganzen ist, beispielsweise 6 pumpen entsprechend nach ihrer laufzeit zu sortieren, um die pumpen mit der geringsten laufzeit als erstes freizugeben, um den verschleiß möglichst konstant zu halten


----------



## volker (18 August 2008)

also doch sortieren. hast du anfangs aber nicht erwähnt.

die andere sachen ist die. wenn du deine pumpen immer so einschaltest, das alle in etwa die gleiche laufzeit haben, werden auch alle ungefähr gleichzeitig kaputt gehen.
ich würde die pumpen normal laufen lassen. hat nun eine pumpe wartungszeit überschritten, kann diese getauscht/gewartet werden und du hast trotzdem noch pumpen die sicher laufen.
wieviele pumpen wann laufen weiss ich ja in deinem fall nicht.


----------



## vierlagig (18 August 2008)

@volker: cosmo scheint in die diskussion gestolpert zu sein, jedenfalls hat er den thread nicht gestartet 

aber deine befürchtungen teil ich, warum alle pumpen gleichzeitig kaputt gehen lassen? damit der servicetechniker nur einmal kommen muß?


----------



## cosmo (21 August 2008)

mmh, das ist natürlich auch ein interessanter punkt, dem im falle des falle wären ja alle pumpen kaputt...


----------



## vollmi (21 August 2008)

cosmo schrieb:


> mmh, das ist natürlich auch ein interessanter punkt, dem im falle des falle wären ja alle pumpen kaputt...



Das sehe ich nicht so. IMHO ist es sinnvoll bei Pumpen einen Betriebsstundenausgleich anzustreben. Vor allem weiss man dann das alle laufen.

Und das alle Pumpen auch nur annähernd bei der gleichen Betriebsstundenanzahl kaputt gehen ist doch sehr unwahrscheinlich.
Je nach Betriebsart sollte man einfach eine sinnvolle umschaltung einstellen, also z.B. alle 1000 Betriebsstunden die Pumpe wechseln.

Und wenn die Pumpen eh nach Anforderungen auch zu mehreren laufen müssen isses eh sinnvoll immer die Pumpe mit der niedrigsten Betriebszeit zuzuschalten.


----------



## marwen42 (8 Februar 2022)

Kai schrieb:


> Hier noch mal ein kurzes Programmbeispiel für die Sortierung von 7 REAL-Zahlen mit Bubblesort:
> 
> 
> ```
> ...





Kai schrieb:


> Hier mal ein kurzes Programmbeispiel mit Bubblesort:
> 
> 
> ```
> ...


Hallo, kann ich den Code verwenden?. Ich soll Laufzeit (DINT)  von 5 Pumpe ermitteln und dann sortieren von kleinste Laufzeit bis größten Laufzeit . und auch Standzeit (DINT)  von 5 Pumpe ermitteln und dann sortieren von größten Standzeit bis kleinste Standzeit.


----------



## Heinileini (8 Februar 2022)

spunky schrieb:


> Hab da ein kleines Problem, ich möchte 6 Real Zahlen vergleichen und die höchste / niedrigste Zahl ermitteln.



Wenn's unbedingt in AWL sein muss und lediglich der kleinste und der grösste Wert aus 6 Variablen gefunden werden sollen:

```
L    Real1   
      L    Real2   
      >=R
      SPB  MIN1
      TAK
MIN1: L    Real3   
      >=R
      SPB  MIN2
      TAK
MIN2: L    Real4   
      >=R
      SPB  MIN3
      TAK
MIN3: L    Real5   
      >=R
      SPB  MIN4
      TAK
MIN4: L    Real6   
      >=R
      SPB  MIN5
      TAK
MIN5: T    MINI     // MIN(Real1, Real2, Real3, Real4, Real5, Real6)     

      L    Real1   
      L    Real2   
      <=R
      SPB  MAX1
      TAK
MAX1: L    Real3   
      <=R
      SPB  MAX2
      TAK
MAX2: L    Real4   
      <=R
      SPB  MAX3
      TAK
MAX3: L    Real5   
      <=R
      SPB  MAX4
      TAK
MAX4: L    Real6   
      <=R
      SPB  MAX5
      TAK
MAX5: T    MAXI     // MAX(Real1, Real2, Real3, Real4, Real5, Real6)
```
Aber in Wirklichkeit ...


spunky schrieb:


> Am Ende soll das für eine Windenüberwachung dienen. Also Positionen (umdrehung der einzelnen Winde wird gezählt 6 Winden ingesamt). Die Winden sollen sich annähernd gleich schnell bewegen (Tolereanz 10 Impulse). Das heisst das die schnellste Winde abgestoppt werden soll, bis die langsamste Winde wieder aufgeholt hat.


... ist die Information gesucht, in welchen der 6 Variablen das Minimum bzw. das Maximum gefunden wird.

Als "Ersatz" für die "Kennung" werden zwölf BOOL-Variablen definiert, damit die Information gebildet werden kann, ohne den Akku-Inhalt zu beeinflussen.
Um die Variable mit dem kleinsten Wert zu identifizieren, wird eine der BOOL-Variablen Bool_11 (für Real1) bis Bool_16 (für Real6) gesetzt.
Um die Variable mit dem grössten Wert zu identifizieren, wird eine der BOOL-Variablen Bool_21 (für Real1) bis Bool_26 (für Real6) gesetzt.
Es kann natürlich vorkommen, dass zwei oder mehr der 6 Variablen den kleinsten oder grössten Wert enthalten, dennoch wird immer nur 1 der BOOL-Variablen Bool_11..Bool_16 (für den MinimalWert) und 1 der BOOL-Variablen Bool_21..Bool_26 (für den MaximalWert) gesetzt.

```
L    Real1   
      L    Real2   
      >=R
      =    Bool_12  // Real2 enthält den kleinsten Wert aus Real1 .. Real6
      SPB  MIN1
      =    Bool_11  // Real1 enthält den kleinsten Wert aus Real1 .. Real6
      TAK
MIN1: L    Real3   
      >=R
      R    Bool_11
      R    Bool_12
      =    Bool_13  // Real3 enthält den kleinsten Wert aus Real1 .. Real6
      SPB  MIN2
      TAK
MIN2: L    Real4   
      >=R
      R    Bool_11
      R    Bool_12
      R    Bool_13
      =    Bool_14  // Real4 enthält den kleinsten Wert aus Real1 .. Real6
      SPB  MIN3
      TAK
MIN3: L    Real5   
      >=R
      R    Bool_11
      R    Bool_12
      R    Bool_13
      R    Bool_14
      =    Bool_15  // Real5 enthält den kleinsten Wert aus Real1 .. Real6
      SPB  MIN4
      TAK
MIN4: L    Real6   
      >=R
      R    Bool_11
      R    Bool_12
      R    Bool_13
      R    Bool_14
      R    Bool_15
      =    Bool_16  // Real6 enthält den kleinsten Wert aus Real1 .. Real6
      SPB  MIN5
      TAK
MIN5: T    MINI     // MIN(Real1, Real2, Real3, Real4, Real5, Real6)     

      L    Real1   
      L    Real2   
      <=R
      =    Bool_22  // Real2 enthält den groessten Wert aus Real1 .. Real6
      SPB  MAX1
      =    Bool_21  // Real1 enthält den groessten Wert aus Real1 .. Real6
      TAK
MAX1: L    Real3   
      <=R
      R    Bool_21
      R    Bool_22
      =    Bool_23  // Real3 enthält den groessten Wert aus Real1 .. Real6
      SPB  MAX2
      TAK
MAX2: L    Real14   
      <=R
      R    Bool_21
      R    Bool_22
      R    Bool_23
      =    Bool_24  // Real4 enthält den groessten Wert aus Real1 .. Real6
      SPB  MAX3
      TAK
MAX3: L    Real5   
      <=R
      R    Bool_21
      R    Bool_22
      R    Bool_23
      R    Bool_24
      =    Bool_25  // Real5 enthält den groessten Wert aus Real1 .. Real6
      SPB  MAX4
      TAK
MAX4: L    Real6   
      <=R
      R    Bool_21
      R    Bool_22
      R    Bool_23
      R    Bool_24
      R    Bool_25
      =    Bool_26  // Real6 enthält den groessten Wert aus Real1 .. Real6
      SPB  MAX5
      TAK
MAX5: T    MAXI     // MAX(Real1, Real2, Real3, Real4, Real5, Real6)
```

Anmerkung zu der ProblemLösung per Sortierung:
Will man durch die SortierAktion wirklich die kompletten 6 (bzw. 7 für den ThreadHijacker) Zeilen der Tabelle sortieren?
Vermutlich nein. Z.B., weil Pumpe1 in der Visualisierung auch weiterhin als Pumpe1 in Zeile 1 erscheinen soll u.s.w..
Man kann aber trotzdem sortieren, indem man der Tabelle 1 Spalte mit Indizes hinzufügt und nur diese neue Spalte sortiert.
Vor dem (ersten) Sortieren dieser neuen Spalten müssen in diese Spalte die ZeilenNrn (1..6 bzw. 1..7) eingetragen werden.
Dann sortiert man die Spalte - nicht nach der Grösse der Inizes, die drin stehen - sondern man liest indirekt in der Spalte, nach der sortiert werden soll, indem man über den Index aus der neuen Spalte auf den Wert aus der Spalte zugreift, nach der sortiert werden soll.
Passt die Reihenfolge nicht zur gewünschten Sortierung, so tauscht man nicht die Werte selbst, sondern ausschliesslich die beiden betroffenen Indizes in der neuen Spalte.
Hat man nach aufsteigenden Werten sortiert, so zeigt der Index der ersten Zeile in der neuen Spalte auf die Zeile der Tabelle, in der der kleinste Wert steht. Ausserdem zeigt der Index der letzten Zeile in der neuen Spalte auf die Zeile der Tabelle, in der der grösste Wert steht.

Falls die Spalte "Kennung" nicht für andere Zwecke beibehalten werden muss, als sie bisher verwendet wird (ausschliesslich zur Identifizierung der Artikel mit dem kleinsten bzw. grössten Wert), dann kann sie entfallen. Ihre Aufgabe wird durch die neue Spalte übernommen.


----------

