Array oder Liste (teil-)sortieren

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

    • Array oder Liste (teil-)sortieren

      :twisted: ...nicht getestet... :twisted:

      Nicht vergessen: Arrays und Listen haben die Basis Null.

      Brainfuck-Quellcode

      1. ' (Teil-)Sortieren von Arrays
      2. ' ---------------------------
      3. ' QuickSort_Long Long_Array&[], min&, max&
      4. ' QuickSort_Str String_Array&[], min&, max&, CaseSense%
      5. ' Wenn CaseSense ungleich Null ist, dann werden
      6. ' die Strings als Lower$()-Werte verglichen.
      7. ' Teil-Sortieren von Listen
      8. ' -------------------------
      9. ' QuickSort_List ListHandle&, min&, max&, CaseSense%, IsNum%
      10. ' Wenn ListHandle& = 0, dann Listbox-Liste.
      11. ' Wenn IsNum ungleich Null ist, dann werden
      12. ' die Werte mittels Val() verglichen -- sonst... --
      13. ' Wenn CaseSense ungleich Null ist, dann werden
      14. ' die Strings als Lower$()-Werte verglichen.
      15. '=================================================
      16. ' (Teil-)Sortieren von Arrays
      17. ' ---------------------------
      18. ' QuickSort_Long Long_Array&[], min&, max&
      19. Proc QuickSort_Long
      20. Parameters Arr&[], Low&, High&
      21. Declare i&, j&, hilf&, mitte&
      22. i& = Low&
      23. j& = High&
      24. mitte& = Arr&[@Int((Low& + High&) / 2)]
      25. While i& <= j&
      26. While Arr&[i&] < mitte&
      27. Inc i&
      28. EndWhile
      29. While Arr&[j&] > mitte&
      30. Dec j&
      31. EndWhile
      32. If i& <= j&
      33. hilf& = Arr&[i&]
      34. Arr&[i&] = Arr&[j&]
      35. Arr&[j&] = hilf&
      36. Inc i&
      37. Dec j&
      38. EndIf
      39. EndWhile
      40. If Low& < j&
      41. QuickSort_Long Arr&[], Low&, j&
      42. EndIf
      43. If i& < High&
      44. QuickSort_Long Arr&[], i&, High&
      45. EndIf
      46. EndProc
      47. ' (Teil-)Sortieren von Arrays
      48. ' ---------------------------
      49. ' QuickSort_Str String_Array&[], min&, max&, CaseSense%
      50. ' Wenn CaseSense ungleich Null ist, dann werden
      51. ' die Strings als Lower$()-Werte verglichen.
      52. Proc QuickSort_Str
      53. Parameters Arr$[], Low&, High&, CaseSense%
      54. Declare i&, j&, hilf$, mitte$
      55. Proc QS_GetStr$
      56. Parameters Wert$
      57. Return If( CaseSense% <> 0, Lower$(Wert$), Wert$ )
      58. EndProc
      59. i& = Low&
      60. j& = High&
      61. mitte$ = QS_GetStr$(Arr$[@Int((Low& + High&) / 2)])
      62. While i& <= j&
      63. While QS_GetStr$(Arr$[i&]) < mitte$
      64. Inc i&
      65. EndWhile
      66. While QS_GetStr$(Arr$[j&]) > mitte$
      67. Dec j&
      68. EndWhile
      69. If i& <= j&
      70. hilf$ = Arr$[i&]
      71. Arr$[i&] = Arr$[j&]
      72. Arr$[j&] = hilf$
      73. Inc i&
      74. Dec j&
      75. EndIf
      76. EndWhile
      77. If Low& < j&
      78. QuickSort_Str Arr$[], Low&, j&, CaseSense%
      79. EndIf
      80. If i& < High&
      81. QuickSort_Str Arr$[], i&, High&, CaseSense%
      82. EndIf
      83. EndProc
      84. ' Teil-Sortieren von Listen
      85. ' -------------------------
      86. ' QuickSort_List ListHandle&, min&, max&, CaseSense%, IsNum%
      87. ' Wenn ListHandle& = 0, dann Listbox-Liste.
      88. ' Wenn IsNum ungleich Null ist, dann werden
      89. ' die Werte mittels Val() verglichen -- sonst... --
      90. ' Wenn CaseSense ungleich Null ist, dann werden
      91. ' die Strings als Lower$()-Werte verglichen.
      92. Proc QuickSort_List
      93. Parameters ListHandle&, Low&, High&, CaseSense%, IsNum%
      94. Declare i&, j&, hilfS$, mitteS$, hilfL&, mitteL&
      95. Proc QS_Get
      96. Parameters Idx&, Ori%
      97. If Ori%
      98. Return GetString$(ListHandle&, Idx&)
      99. Else
      100. If IsNum%
      101. Return Val(GetString$(ListHandle&, Idx&))
      102. Else
      103. Return If( CaseSense% <> 0, Lower$(Wert$), Wert$ )
      104. EndIf
      105. EndIf
      106. EndProc
      107. Proc QS_Put
      108. Parameters Idx&, Wert$
      109. ReplaceString(ListHandle&, Idx&, Wert$)
      110. EndProc
      111. i& = Low&
      112. j& = High&
      113. If IsNum%
      114. mitteL& = QS_Get(@Int((Low& + High&) / 2), 0)
      115. Else
      116. mitteS$ = QS_Get(@Int((Low& + High&) / 2), 0)
      117. EndIf
      118. While i& <= j&
      119. If IsNum%
      120. While QS_Get(i&,0) < mitteL&
      121. Inc i&
      122. EndWhile
      123. While QS_Get(j&,0) > mitteL&
      124. Dec j&
      125. EndWhile
      126. Else
      127. While QS_Get(i&,0) < mitteS$
      128. Inc i&
      129. EndWhile
      130. While QS_Get(j&,0) > mitteS$
      131. Dec j&
      132. EndWhile
      133. EndIf
      134. If i& <= j&
      135. hilfS$ = QS_Get(i&,1)
      136. QS_Put(i&, QS_Get(j&,1))
      137. QS_Put(j&, hilfS$)
      138. Inc i&
      139. Dec j&
      140. EndIf
      141. EndWhile
      142. If Low& < j&
      143. QuickSort_List ListHandle&, Low&, j&, CaseSense%, IsNum%
      144. EndIf
      145. If i& < High&
      146. QuickSort_List ListHandle&, i&, High&, CaseSense%, IsNum%
      147. EndIf
      148. EndProc
      Alles anzeigen


      Ach ja: ... und bei sortierten Listen macht QuickSort_List besonders viel Spaß :evil:

      und jetzt
      Gute Nacht :sleeping:
      Michael Wodrich
      Programmieren, das spannendste Detektivspiel der Welt.
    • Oh, :roll: da war ich wohl sehr müde.

      Hier das funktionsfähige Teil mit kleinem Testcode am Ende.

      Brainfuck-Quellcode

      1. ' (Teil-)Sortieren von Arrays
      2. ' ---------------------------
      3. ' QuickSort_Long Long_Array&[], min&, max&
      4. ' QuickSort_Str String_Array&[], min&, max&, CaseSense%
      5. ' Wenn CaseSense ungleich Null ist, dann werden
      6. ' die Strings als Lower$()-Werte verglichen.
      7. ' Teil-Sortieren von Listen
      8. ' -------------------------
      9. ' QuickSort_List ListHandle&, min&, max&, CaseSense%, IsNum%
      10. ' Wenn ListHandle& = 0, dann Listbox-Liste.
      11. ' Wenn IsNum ungleich Null ist, dann werden
      12. ' die Werte mittels Val() verglichen -- sonst... --
      13. ' Wenn CaseSense ungleich Null ist, dann werden
      14. ' die Strings als Lower$()-Werte verglichen.
      15. '=================================================
      16. ' (Teil-)Sortieren von Arrays
      17. ' ---------------------------
      18. ' QuickSort_Long Long_Array&[], min&, max&
      19. Proc QuickSort_Long
      20. Parameters Arr&[], Low&, High&
      21. Declare i&, j&, hilf&, mitte&
      22. i& = Low&
      23. j& = High&
      24. mitte& = Arr&[@Int((Low& + High&) / 2)]
      25. While i& <= j&
      26. While Arr&[i&] < mitte&
      27. Inc i&
      28. EndWhile
      29. While Arr&[j&] > mitte&
      30. Dec j&
      31. EndWhile
      32. If i& <= j&
      33. hilf& = Arr&[i&]
      34. Arr&[i&] = Arr&[j&]
      35. Arr&[j&] = hilf&
      36. Inc i&
      37. Dec j&
      38. EndIf
      39. EndWhile
      40. If Low& < j&
      41. QuickSort_Long Arr&[], Low&, j&
      42. EndIf
      43. If i& < High&
      44. QuickSort_Long Arr&[], i&, High&
      45. EndIf
      46. EndProc
      47. ' (Teil-)Sortieren von Arrays
      48. ' ---------------------------
      49. ' QuickSort_Str String_Array&[], min&, max&, CaseSense%
      50. ' Wenn CaseSense ungleich Null ist, dann werden
      51. ' die Strings als Lower$()-Werte verglichen.
      52. Proc QuickSort_Str
      53. Parameters Arr$[], Low&, High&, CaseSense%
      54. Declare i&, j&, hilf$, mitte$
      55. Proc QS_GetStr$
      56. Parameters Wert$
      57. Return If( CaseSense% <> 0, Lower$(Wert$), Wert$ )
      58. EndProc
      59. i& = Low&
      60. j& = High&
      61. mitte$ = QS_GetStr$(Arr$[@Int((Low& + High&) / 2)])
      62. While i& <= j&
      63. While QS_GetStr$(Arr$[i&]) < mitte$
      64. Inc i&
      65. EndWhile
      66. While QS_GetStr$(Arr$[j&]) > mitte$
      67. Dec j&
      68. EndWhile
      69. If i& <= j&
      70. hilf$ = Arr$[i&]
      71. Arr$[i&] = Arr$[j&]
      72. Arr$[j&] = hilf$
      73. Inc i&
      74. Dec j&
      75. EndIf
      76. EndWhile
      77. If Low& < j&
      78. QuickSort_Str Arr$[], Low&, j&, CaseSense%
      79. EndIf
      80. If i& < High&
      81. QuickSort_Str Arr$[], i&, High&, CaseSense%
      82. EndIf
      83. EndProc
      84. ' Teil-Sortieren von Listen
      85. ' -------------------------
      86. ' QuickSort_List ListHandle&, min&, max&, CaseSense%, IsNum%
      87. ' Wenn ListHandle& = 0, dann Listbox-Liste.
      88. ' Wenn IsNum ungleich Null ist, dann werden
      89. ' die Werte mittels Val() verglichen -- sonst... --
      90. ' Wenn CaseSense ungleich Null ist, dann werden
      91. ' die Strings als Lower$()-Werte verglichen.
      92. Proc QuickSort_List
      93. Parameters ListHandle&, Low&, High&, CaseSense%, IsNum%
      94. Declare i&, j&, hilfS$, mitteS$, hilfL&, mitteL&, tmp$
      95. Proc QS_Get
      96. Parameters Idx&, Ori%
      97. If Ori%
      98. Return GetString$(ListHandle&, Idx&)
      99. Else
      100. If IsNum%
      101. Return Val(GetString$(ListHandle&, Idx&))
      102. Else
      103. ' noch ein Sortiertrick - die Umlaute umsetzen
      104. tmp$ = GetString$(ListHandle&, Idx&)
      105. tmp$ = Translate$(tmp$,"Ä","Ae")
      106. tmp$ = Translate$(tmp$,"Ö","Oe")
      107. tmp$ = Translate$(tmp$,"Ü","Ue")
      108. tmp$ = Translate$(tmp$,"ä","ae")
      109. tmp$ = Translate$(tmp$,"ö","oe")
      110. tmp$ = Translate$(tmp$,"ü","ue")
      111. tmp$ = Translate$(tmp$,"ß","ss")
      112. Return If( CaseSense% <> 0, Lower$(tmp$), tmp$ )
      113. EndIf
      114. EndIf
      115. EndProc
      116. Proc QS_Put
      117. Parameters Idx&, Wert$
      118. ReplaceString(ListHandle&, Idx&, Wert$)
      119. EndProc
      120. i& = Low&
      121. j& = High&
      122. If IsNum%
      123. mitteL& = QS_Get(@Int((Low& + High&) / 2), 0)
      124. Else
      125. mitteS$ = QS_Get(@Int((Low& + High&) / 2), 0)
      126. EndIf
      127. While i& <= j&
      128. If IsNum%
      129. While QS_Get(i&,0) < mitteL&
      130. Inc i&
      131. EndWhile
      132. While QS_Get(j&,0) > mitteL&
      133. Dec j&
      134. EndWhile
      135. Else
      136. While QS_Get(i&,0) < mitteS$
      137. Inc i&
      138. EndWhile
      139. While QS_Get(j&,0) > mitteS$
      140. Dec j&
      141. EndWhile
      142. EndIf
      143. If i& <= j&
      144. hilfS$ = QS_Get(i&,1)
      145. QS_Put(i&, QS_Get(j&,1))
      146. QS_Put(j&, hilfS$)
      147. Inc i&
      148. Dec j&
      149. EndIf
      150. EndWhile
      151. If Low& < j&
      152. QuickSort_List ListHandle&, Low&, j&, CaseSense%, IsNum%
      153. EndIf
      154. If i& < High&
      155. QuickSort_List ListHandle&, i&, High&, CaseSense%, IsNum%
      156. EndIf
      157. EndProc
      158. ' TEST TEST TEST TEST TEST TEST TEST TEST
      159. cls
      160. declare s$[], n&[]
      161. print "Der Sortierbereich ist in Klammern angegeben:\n"
      162. print " aus: Zitrone,Orange,Banane,Apfel (0..3)\n"
      163. print "wird:";
      164. s$[] = explode("Zitrone,Orange,Banane,Apfel", ",")
      165. QuickSort_Str s$[], 0, 3, 0
      166. WhileLoop 0, SizeOf(s$[]) - 1
      167. Print " ";s$[&Loop];
      168. EndWhile
      169. Print "."
      170. waitkey
      171. print "\n\n aus: Zitrone,Orange,Banane,Apfel (1..2)\n"
      172. print "wird:";
      173. s$[] = explode("Zitrone,Orange,Banane,Apfel", ",")
      174. QuickSort_Str s$[], 1, 2, 0
      175. WhileLoop 0, SizeOf(s$[]) - 1
      176. Case &Loop = 1 : Color 12,15
      177. Case &Loop = 3 : Color 0,15
      178. Print " ";s$[&Loop];
      179. EndWhile
      180. Print "."
      181. waitkey
      182. print "\n...jetzt LongInt...\n"
      183. print " aus: 37;81;19;7;12;24;80 (0..6)\n"
      184. print "wird:";
      185. n&[0]=37:n&[1]=81:n&[2]=19:n&[3]=7:n&[4]=12:n&[5]=24:n&[6]=80
      186. QuickSort_Long n&[], 0, 6
      187. WhileLoop 0, SizeOf(n&[]) - 1
      188. Print " ";n&[&Loop];
      189. EndWhile
      190. Print "."
      191. waitkey
      192. print "\n\n aus: 37;81;19;7;12;24;80 (2..4)\n"
      193. print "wird:";
      194. n&[0]=37:n&[1]=81:n&[2]=19:n&[3]=7:n&[4]=12:n&[5]=24:n&[6]=80
      195. QuickSort_Long n&[], 2, 4
      196. WhileLoop 0, SizeOf(n&[]) - 1
      197. Case &Loop = 2 : Color 12,15
      198. Case &Loop = 5 : Color 0,15
      199. Print " ";n&[&Loop];
      200. EndWhile
      201. Print "."
      202. waitkey
      203. cls
      204. print "\n...jetzt Listenbereich (3..7), danach Gesamt...\n"
      205. print " aus: Emil,Dora,Cäsar,Berta,Ärger,Anton,Xaver,Franz,Friedrich,Helga,Otto,Paul\n"
      206. print "wird:";
      207. declare hliste&
      208. hListe& = 0 ' Listbox-Liste
      209. ClearList hListe&
      210. MoveStrToList("Emil,Dora,Cäsar,Berta,Ärger,Anton,Xaver,Franz,Friedrich,Helga,Otto,Paul", ",")
      211. QuickSort_List hListe&, 3, 7, 1, 0
      212. WhileLoop 0, GetCount(hListe&) - 1
      213. Case &Loop = 3 : Color 12,15
      214. Case &Loop = 8 : Color 0,15
      215. Print " ";GetString$(hListe&, &Loop);
      216. EndWhile
      217. Print "."
      218. waitkey
      219. print "\n\n aus: Emil,Dora,Cäsar,Berta,Ärger,Anton,Xaver,Franz,Friedrich,Helga,Otto,Paul\n"
      220. print "wird:";
      221. ClearList hListe&
      222. MoveStrToList("Emil,Dora,Cäsar,Berta,Ärger,Anton,Xaver,Franz,Friedrich,Helga,Otto,Paul", ",")
      223. QuickSort_List hListe&, 0, (GetCount(hListe&) - 1), 1, 0
      224. WhileLoop 0, GetCount(hListe&) - 1
      225. Print " ";GetString$(hListe&, &Loop);
      226. EndWhile
      227. Print "."
      228. waitkey
      229. End
      Alles anzeigen
      Programmieren, das spannendste Detektivspiel der Welt.