Nur den zuletztgedrückten Button benutzen

[NicTheQuick]

Okay, zugegeben. LinkedLists sind langsamer als Arrays, was mein nachfolgender Test auch bezeugt.

ABER:
Es beläuft sich hier in Größenordnungen, die bei einer Tastatursteuerung mit maximal 256 Tasten nicht auffallen. Laut meiner Hochrechnung macht der Unterschied bei 6 Tasten maximal 3 µs aus.

Hier der Testcode

Code: Alles auswählen

#Max = 1000000
a.l

;Array allokieren und füllen
t_Array_in.l = ElapsedMilliseconds()

  Dim Array.l(#Max)
  For a = 0 To #Max
    Array(a) = Random($7FFFFFFF)
  Next

t_Array_in = ElapsedMilliseconds() - t_Array_in

;LinkedList allokieren und füllen
t_LL_in.l = ElapsedMilliseconds()

  NewList LL.l()
  For a = 0 To #Max
    AddElement(LL())
    LL() = Random($7FFFFFFF)
  Next

t_LL_in = ElapsedMilliseconds() - t_LL_in

;Array wieder auslesen
t_Array_out.l = ElapsedMilliseconds()

  For a = 0 To #Max
    Result.l = Array(a)
  Next

t_Array_out = ElapsedMilliseconds() - t_Array_out

;LinkedList wieder auslesen
t_LL_out.l = ElapsedMilliseconds()

  ForEach LL()
    Result = LL()
  Next

t_LL_out = ElapsedMilliseconds() - t_LL_out

;Gesamte LinkedList löschen (ClearList())
t_LL_Clear.l = ElapsedMilliseconds()

  ClearList(LL())

t_LL_Clear = ElapsedMilliseconds() - t_LL_Clear

;Schnell wieder füllen für andere Löschmethode
For a = 0 To #Max
  AddElement(LL())
  LL() = Random($7FFFFFFF)
Next

;Gesamte LinkedList löschen (DeleteElement())
t_LL_Delete.l = ElapsedMilliseconds()

  ForEach LL()
    DeleteElement(LL())
  Next

t_LL_Delete = ElapsedMilliseconds() - t_LL_Delete

Text.s
Text = "Array:" + #CRLF$
Text + "- Allokieren & Füllen: " + Chr(9) + Str(t_Array_in) + " ms" + #CRLF$
Text + "- Auslesen: " + Chr(9) + Chr(9) + Str(t_Array_out) + " ms"  + #CRLF$ + #CRLF$
Text + "LinkedList: " + #CRLF$
Text + "- Allokieren & Füllen: " + Chr(9) + Str(t_LL_in) + " ms"  + #CRLF$
Text + "- Auslesen: " + Chr(9) + Chr(9) + Str(t_LL_out) + " ms"  + #CRLF$
Text + "- ClearList: " + Chr(9) + Chr(9) + Str(t_LL_Clear) + " ms"  + #CRLF$
Text + "- DeleteElement: " + Chr(9) + Chr(9) + Str(t_LL_Delete) + " ms"  + #CRLF$

MessageRequester("Auswertung", Text)

[Froggerprogger]

etwas Senf:
LinkedLists sind schneller, wenn es viele Einfügungen und Löschungen gibt, bei denen die Realisierung durch Arrays darauf angewiesen wäre, den nachfolgenden Array-Bereich komplett zu verschieben.
Ansonsten sind sie langsamer, aber weitaus flexibler.

[Ynnus]

Es geht mir ja auch nicht im eigentlichen Sinne um dieses Tastatur-Beispiel sonder vielmehr um den Hinweis, wie und wo man da optimieren könnte.
Für die Zukunft sollte man eben darauf achten, nicht verschwenderisch mit den Mitteln umzugehen. Und wenn man bei 4 fixen Elementen auch ein Array nehmen könnte, finde ich die LinkedLists unnötig, da es ja auch immer 4 Glieder bleiben (nach meiner Methode jedenfalls mit Aufrücken von leeren Elementen und so) und da muss man nicht mit 4 Elementen + LL handlen. Bleibt aber jedem selbst überlassen, ich hab nur leider schonmal Erfahrung gemacht mit Nicht-Optimierung und danach der große Aufschrei.