Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Nächste Überarbeitung		 Vorherige Überarbeitung
gf_informatik:suchen_und_sortieren_2024 [2024-01-22 14:01] – ↷ Links angepasst weil Seiten im Wiki verschoben wurden hofgf_informatik:suchen_und_sortieren [2026-04-04 20:02] (aktuell) – hof
Zeile 1: Zeile 1:
 ====== Suchen und Sortieren ====== ====== Suchen und Sortieren ======
 +<html><script type="module" src="https://bottom.ch/editor/stable/bottom-editor.js"></script></html>
  
-Weiter zu [[gf_informatik:suchen_und_sortieren_2023:binaersuche|Binäre Suche]]+Weiter zu [[gf_informatik:suchen_und_sortieren:binaersuche|Binäre Suche]]
  
 Direkt zu [[gf_informatik:suchen_und_sortieren:sortieren|Sortieren]] Direkt zu [[gf_informatik:suchen_und_sortieren:sortieren|Sortieren]]
 +
 +++++Lernziele lineare und binäre Suche:|
 +   * Ich kann erklären, wie die lineare Suche und wie die binäre Suche funktioniert.
 +   * Ich kann die beiden Such-Algorithmen (linear und binär) miteinander vergleichen, d.h. Unterschiede, Vor- und Nachteile/Voraussetzungen erklären. 
 +   * Ich kann für eine gegebene Anzahl Einträge (Listen-Länge) die maximale Anzahl Abfragen für beide Such-Algorithmen berechnen.
 +   * Ich kann eine Funktion ''linear\_search(list, value)'' definieren, die nach der linearen Suche die **Position** von ''value'' in ''list'' zurückgibt. 
 +   * Ich kann eine Funktion ''binary\_search(list, value)'' definieren, die nach der binären Suche die **Position** von ''value'' in ''list'' zurückgibt.
 +   * Ich kann Suchfunktionen (linear und binär) verwenden, um in mehreren zusammenpassenden Listen zusammengehörende Elemente zu finden – Beispiel: Ausgehend vom Namen über dessen Index in der Namensliste die entsprechende Nummer aus der Nummernliste ermitteln.
 +++++
 +
  
 ==== Einführung ==== ==== Einführung ====
Zeile 22: Zeile 33:
  
 Der Sänger von _079_ will die Telefonnummer der Angebeteten unter allen möglichen Schweizer Mobilfunknummern (10-stellig) mit dem Präfix `079` herausfinden. Dafür probiert er sämtliche Nummern von `079 000 00 00` bis `079 999 99 99` durch, was natürlich ziemlich lange dauert... Der Sänger von _079_ will die Telefonnummer der Angebeteten unter allen möglichen Schweizer Mobilfunknummern (10-stellig) mit dem Präfix `079` herausfinden. Dafür probiert er sämtliche Nummern von `079 000 00 00` bis `079 999 99 99` durch, was natürlich ziemlich lange dauert...
- 
  
 #### Aufgabe A1 - 079 #### Aufgabe A1 - 079
  
-**Tipp**: [[https://www.youtube.com/watch?v=C8Xv7MKigYo|Liedtext]] hören!+**Tipp**: Höre oder lese den Liedtext genau ([[https://www.songtexte.com/songtext/lo-and-leduc/079-g5bed3b18.html|Original]], [[https://www.swr3.de/musik/poplexikon/lyrics/lo--leduc-079--songtext-deutsche-bersetzung--lyrics-100.html|Hochdeutsch]], [[https://www.youtube.com/watch?v=C8Xv7MKigYo|Youtube]])!
  
 1. Wie viele Telefonnummern muss der Sänger von _079_ durchprobieren? 1. Wie viele Telefonnummern muss der Sänger von _079_ durchprobieren?
Zeile 34: Zeile 44:
 1. Wie lange dauerte die Suche, wenn wir nicht einmal die Vorwahl kennen würden (aber wüssten, dass alle Nummern mit `0` beginnen)? 1. Wie lange dauerte die Suche, wenn wir nicht einmal die Vorwahl kennen würden (aber wüssten, dass alle Nummern mit `0` beginnen)?
  
-<nodisp 2>+<nodisp 1>
 ++++Lösung| ++++Lösung|
  
Zeile 47: Zeile 57:
  
 === Algorithmus === === Algorithmus ===
-Der einfachste Such-Algorithmus probiert alle Telefonnummern von der kleinsten zur grössten durch. Die Zeit für die Suche steigt proportional mit der Anzahl möglichen Nummern an - wir sagen auch, dass die Zeit **linear** mit der Grösse des Suchbereichs wächst, und sprechen von **Linearer Suche**.+Der einfachste Such-Algorithmus probiert alle Telefonnummern von der kleinsten zur grössten durch. Die Zeit für die Suche steigt **proportional** mit der Anzahl möglichen Nummern an - wir sagen auch, dass die Zeit **linear** mit der Grösse des Suchbereichs wächst, und sprechen von **Linearer Suche**.
  
 Würden wir statt _079_ nicht einmal die Vorwahl kennen, wäre die Suche nochmals zwei Dezimalstellen länger (wenn alle Telefonnummern mit 0 beginnen). Wir müssten also statt 6.5 sogar über 600 Jahre suchen. Würden wir statt _079_ nicht einmal die Vorwahl kennen, wäre die Suche nochmals zwei Dezimalstellen länger (wenn alle Telefonnummern mit 0 beginnen). Wir müssten also statt 6.5 sogar über 600 Jahre suchen.
Zeile 56: Zeile 66:
 === Aufgabe A2: Lineare Suche in Python === === Aufgabe A2: Lineare Suche in Python ===
  
-Betrachte folgenden Datensatz mit Namen und Telefonnummern. Wir haben zwei parallele Listen, die erste mit Namen, die zweite mit den dazugehörigen Telefonnummern.+Betrachte folgenden Datensatz mit Namen und Telefonnummern. Wir haben zwei parallele Listen, die erste mit Namen, die zweite mit den dazugehörigen Telefonnummern. Am gleichen Index ist in der ersten Liste der Name, in der zweiten die Telefonnummer gespeichert.
  
-Zum Beispiel ist die Telefonnummer von Anela 0790000001.+Zum Beispiel finden wir für den Index `1` Anela in `names[1]` und ihre Nummer 0790000001 in `numbers[1]`.
  
-<code python lineare_suche.py>+<html><bottom-editor autorun>
 names = ['Aja', 'Anela', 'Arwen', 'Isra', names = ['Aja', 'Anela', 'Arwen', 'Isra',
          'Juno', 'Kaida', 'Loelia', 'Luna',          'Juno', 'Kaida', 'Loelia', 'Luna',
          'Lumiel', 'Lyanna', 'Meyra', 'Miriel',          'Lumiel', 'Lyanna', 'Meyra', 'Miriel',
          'Narcissa', 'Nisha', 'Runa', 'Yuna']          'Narcissa', 'Nisha', 'Runa', 'Yuna']
-numbers = ['0790000000', '0790000001', '00790000002', '0790000003',+numbers = ['0790000000', '0790000001', '0790000002', '0790000003',
            '0790000004', '0790000005', '0790000006', '0790000007',            '0790000004', '0790000005', '0790000006', '0790000007',
            '0790000008', '0790000009', '0790000010', '0790000011',            '0790000008', '0790000009', '0790000010', '0790000011',
            '0790000012', '0790000013', '0790000014', '0790000015']            '0790000012', '0790000013', '0790000014', '0790000015']
-</code> +</bottom-editor></html> 
-  - Schreibe eine Python-Funktion `linear_search(l, v)`. Die Funktion soll in der Liste ''l'' nach dem Wert ''v'' suchen. Falls es gefunden wird, soll __die Position (Index)__ des Elements in der Liste //zurückgegeben// werden (*nicht* geprintet!).  + 
-  - Test: Der Funktionsaufruf `print(linear_search(names, 'Anela'))` soll $2$ ausgeben.+  - Schreibe eine Python-Funktion `linear_search(l, v)`. Die Funktion soll in der Liste ''l'' nach dem Wert ''v'' suchen. Falls er gefunden wird, soll __die Position (Index)__ des Elements in der Liste //zurückgegeben// werden (*nicht* geprintet!).  
 +  - Test: Der Funktionsaufruf `print(linear_search(names, 'Anela'))` soll $1$ ausgeben.
   - Nun wissen wir, dass die gesuchte Dame `Lyanna` (_die Geheimnisvolle_) heisst. Nutze nun diese Funktion, um die Telefonnummer von 'Lyanna' zu ermitteln.   - Nun wissen wir, dass die gesuchte Dame `Lyanna` (_die Geheimnisvolle_) heisst. Nutze nun diese Funktion, um die Telefonnummer von 'Lyanna' zu ermitteln.
  
Zeile 77: Zeile 88:
  
 ++++Tipps (zuerst ohne Tipps versuchen!)| ++++Tipps (zuerst ohne Tipps versuchen!)|
-  - Gehe IN der Funktion die Liste alle möglichen Indices (Positionen) durch. +  - Gehe IN der Funktion die Liste `l` alle möglichen Indices (Positionen) durch ([[gf_informatik:programmieren_iii#indirekte_for-schleife|indirekte for-Schleife]]). 
-  - Vergleiche das Element an jedem Index mit dem gesuchten Wert. +  - Vergleiche das Element an jedem Index (also `l[index]`) mit dem gesuchten Wert `v`. 
-  - Wenn es gleich ist: Gebe den Index zurück.+  - Wenn es gleich ist: Gib den Index zurück.
   - Ausserhalb der Funktion: Lese nun aus der **anderen** Liste das Element mit dem eben ermittelten Index aus.   - Ausserhalb der Funktion: Lese nun aus der **anderen** Liste das Element mit dem eben ermittelten Index aus.
 ++++ ++++
Zeile 86: Zeile 97:
 <nodisp 1> <nodisp 1>
 ++++Lösung| ++++Lösung|
-<code python>+<html><bottom-editor>
 def linear_search(l, v): def linear_search(l, v):
     for i in range(len(l)):     for i in range(len(l)):
Zeile 95: Zeile 106:
 index = linear_search(names, 'Lyanna') index = linear_search(names, 'Lyanna')
 print(numbers[index]) print(numbers[index])
-</code>+</bottom-editor></html>
 ++++ ++++
 </nodisp> </nodisp>
Zeile 102: Zeile 113:
 Für das kleine Telefonbuch oben ist es nicht so wichtig, wie schnell der Such-Algorithmus ist. Was aber, wenn wir wirklich alle 10 Millionen Kombinationen durchprobieren? Für das kleine Telefonbuch oben ist es nicht so wichtig, wie schnell der Such-Algorithmus ist. Was aber, wenn wir wirklich alle 10 Millionen Kombinationen durchprobieren?
  
-Lade die Datei [[https://kantonsschuleromanshorn.sharepoint.com/:u:/s/FSInformatik/EQpO02ZUBldHmbYjEgKka_YBeaBaTHf1IUd-lrtYrdZJkA?download=1|null79.py]] herunter und speichere sie im selben Verzeichnis wie dein Code.+Für diese Aufgabe benötigst du zusätzlich eine weitere Python-Datei, `null79.py`, die wir in unserem selbstgeschriebenen Code importieren. Dazu verwenden wir ähnlich wie zu Turtle-Zeiten das Schlüsselwort `import`. 
 + 
 +Verwende deine `linear_search()` Funktion, um die richtige Telefonnummer von Lyanna herauszufinden. Wie lange dauert die Suche? 
 + 
 +<html><bottom-editor timeout="180" zip="https://sca.ksr.ch/lib/exe/fetch.php?media=gf_informatik:programmieren_i:null79.py.zip" session="10m"> 
 +from null79 import names, numbers 
 + 
 +index = 42  # TODO: Suche den Index von Lyanna! 
 +name = names[index] 
 +tel = numbers[index] 
 +print(f'Die Telefonnummer von {name} ist {tel}') 
 +</bottom-editor></html> 
 + 
 +Oben ist die Datei `null79.py` bereits im gleichen Ordner hinterlegt - wenn du den Code in TigerJython oder VisualStudioCode ausführst, muss die Datei ebenfalls dort abgespeichert werden. 
 + 
 +== Mit WebTigerPython == 
 +Am einfachsten geht das mit [[https://wtp.ethz.ch/#?code=NobwRAdghgtgpmAXGANgezQBwHSYJ5gA0YAJlAC5RJgCMADAEyE00AszLzdAnIQMxMW7FgHYOdcVxod2ArgFYuvFoM5COANn6C6Y-ovoAOLse6LueusaOEzm23poHdHRXPpdLz61dvnLPqYGNFoWrp7hrBKsNGAAvoTg0PDUMFAAlhC4BMRklNQAZgBOaDAABBAArigoItxl6TCYaEXkFbBwAM6EFZUwAEZwRZ0AOhBlY5kkcAAeZQC8ZawMZWUAxGUAKgDyACLbiGUAypUAxgAWcGXT4wCSENNzAG5o4wAyeFAQ0ACEY8lXRYAzrAKazAC6Y3IcBQECKC16AyGILBM0hEEwRUy5AAFAUAOS7dJXTYwuAFV5VGDweEvcYgAFxBqdNogaGwopxfEASniiUgHWoVRqdWyRFIFCoyDWPwA9JVOkVZf1MrL8ORzq8xhsALQAKh1ZVOaBImQA5odKuQCoYyvqdZMmi02uRGnAeiysRAzT00hqxmNTigoJ1OsdMFBhnAAAqaiBwABCGAA1jjuYgxqtViMwDmcwBBMqdCNRsoodIssoaihlIpwciVIoQMMaq51p7IuAkBo3V3kPBlCnwqBlM3pDvjVE9THk9IzLtlADu6X94yzWZHM4Kc-wedzubXq2mBTKAH1T5kV-ecZ0YQVp3XtzN5jndNwc-nM-us7eUAVsKeKBwN6GoIvQdAQZBX7fkWd4AVuc4IghMwBoe1zkmegHAdev4FJ-aHrnWDZNrBf4AUBIHnKh67HphZr1iucAwDhd49Ok-Ewas6Qnv2mBwDi7HMhUaBtNiGYEZxRQZLeZT3I8ACiRQlEUOI5vcTxQOW3aoocOZlAA1EW5Aqex3LQd-3ENGUAA8ZR0OJnEWQZiwUTed5mRJXEnnQNmLOkNllsBbl_hxjlZkRjbjLh8GPohhlDn6OKubh3J2mUNBpekPSvnphmegJEC4n65zYOgZr0ElQUpdyNUGRMkAfuZhHSVccmzIpymqWAbVzGgVplGgJ5Sd6cC6WAdX5aZqFBiGYZHCWt5vBWuKhdm-4FkWC3umUmmYOcUCDK6pyaSgA6dM6C7lpW1ZtNM0JFDAl4sukx01AOEVNmGUBNasAKDi0ZRwFAFyjuOwENA8sw9LMpxwJgbRDjtsGnERZTJnAeCyhpKCVFcEbpEUu7rQeNEYeel7kCxf49BRZoah6cAo_Wp7o3gDNM5T2O4z00zBng8x0Kt37RaevNQAOixi3gP2rCLtOgS5wF01Rnmkf-p63hzLMYwimtEdr0uqyLevM1zgLI_rZsy2rAEvIuMJhos-JQHA6R9fi1si8azavF85CO2UwAg4jIOZEZXpmtgIanOk6SAWg9tFMdMmWSDEAiRDNunnbDvoo5IskH1_RAQH-L9CQBRmigMAYsM5Ae0bcGnhSNQJ8iusXSQwXqznKBhnlTeF5UxddB55m0eeFFU3hDmSfWkVZ_LKvruPZPxjMlO7fth3dzTIbkEL67BpWLn76VbcqR5jmWcf5DADqNDgpnIu950s9hbW88kV7rzndAhWjFVjfIKt9Uq2QYO_MKH0opN1ftbG--974MCfmHH-Pt_7-0gY5aBWc4GqxwSLFu6BE6AJXmhCe9F4xSWhKeAEu8GiHyzHuHMux6xDEehAZaL0ToDkoUMCgVxWztHgDtUSkM5j-WKKUKslwdoaXSMGEeO0UB7QOvWMogwhxXBNpzTSuMibMIgPAk8_l5iLGNozfWrMsFz2IjAsiGtLGmz0XAYxVlbIWK1tY6264WSRjaIsOgPiszAW7OYpuOiDbBNWFvNRATw7mijp0GOcdKiYD4knEMcBgD2U9Ik6OsdTxpIycnOA2BUTdwApEs2OTwTcjzh_MsCJXKxMOlfTiDtRrRKMv43WESnGU1ZnVGg3TQnNKqu5bprT1HmOMvk5JhTilDFKcAPJ3okkpKKek5ZWTyniMqY4rWNS6B1P0jQRADSP7-R1OEhxkShmGRGUY1WGx5rljaKsygrREChJQYVNATS4AAEdKiaR1J0dIAAvBc2IhjYzDINJGS8BongOn1MR91sayhQNbFA4yIA4mmQfa2YSyjFWwLDBROIcRjMNH41oqVZRlnaTBVECJsQCTKLKJlJAWXfj-osIloJxGXKcn5MoABSa41FOKLnOAoq43YAB86UbEwSJX0hx69N4qO3vWHEAI-WOTxYrAlRKjWcVJeSylKAcTdiZSgC1rLxHssKpy7l1wnX8o6M5ZRqjDrCseKK6-7LJXSvwV_cYAIZVHjJqeeifYmLTzYow1Yrp4DYE6EBOGBypZessrxfigkKzCQxWq78UkKytXER1FoXV1KaXSNpcRY0JrGQEjVNx_lbL2W6f5fSpru75pMQsW56t7kY3LYRSNWdqkuOtgQpufDqFwFoR0DtqEqSDGGAieakZbyxleImFMXU3yNW-B0AOe6oxLRZDicCkEII9D4GYPghhlg9HxB8L40AeTxHBEAA|diesem WebtigerPython-Link]] - die Datei ist hier bereits hinterlegt. 
 + 
 +++++ Mit TigerPython / VisualStudioCode :| 
 +Lade die Datei [[https://kantonsschuleromanshorn.sharepoint.com/:u:/s/FSInformatik/EQpO02ZUBldHmbYjEgKka_YBeaBaTHf1IUd-lrtYrdZJkA?download=1|null79.py]] herunter und speichere sie im selben Ordner wie dein Code.
  
-Du kannst das Telefonbuch wie folgt importieren und den Namen für eine Telefonnummer herausfinden. Der Code muss im gleichen Ordner wie `null79.py` abgespeichert werden (**funktioniert nur in TigerJython, aber nicht in WebTigerJython**)!+Du kannst das Telefonbuch wie folgt importieren und den Namen für eine Telefonnummer herausfinden. Der Code muss im gleichen Ordner wie `null79.py` abgespeichert werden!
  
 <code python> <code python>
 from null79 import names, numbers from null79 import names, numbers
  
-index = 42+index = 42  # TODO: Suche den Index von Lyanna!
 name = names[index] name = names[index]
-telnr = numbers[index] +tel = numbers[index] 
-print("Die Telefonnummer von " + name + " ist " + telnr)+print(f'Die Telefonnummer von {name} ist {tel}')
 </code> </code>
 +++++
 +== Aufgabe ==
  
-Verwende deine `linear_search()` Funktion, um die richtige Telefonnummer von Lyanna herauszufinden. Wie lange dauert die Suche? 
  
-<nodisp 2>+<nodisp 1>
 ++++Lösung mit Code| ++++Lösung mit Code|
-<code python Aufgabe A3.py>+<html><bottom-editor timeout="180" zip="https://sca.ksr.ch/lib/exe/fetch.php?media=gf_informatik:programmieren_i:null79.py.zip" session="10m">
 from null79 import names, numbers from null79 import names, numbers
  
Zeile 129: Zeile 160:
  
 name = 'Lyanna' name = 'Lyanna'
-idx = linear_search(names, name) +index = linear_search(names, name) 
-if idx is None:+if index == None:
     print("Du weisch immer no nüt het si gseit")     print("Du weisch immer no nüt het si gseit")
 else: else:
-    tel = numbers[idx] +    tel = numbers[index] 
-    print("Die Telefonnummer von " + name + " ist " + tel)+    print(f'Die Telefonnummer von {name} ist {tel}')
     print("144 hei si gseit!")     print("144 hei si gseit!")
-    print("Wie isch das nume passiert, hei si seit.") +    print("Wie isch das nume passiert, hei si gseit.") 
-    print("Hueresiech, hei si seit, ey") +    print("Hueresiech, hei si gseit, ey") 
-</code>+</bottom-editor></html>
  
 ++++ ++++
Zeile 146: Zeile 177:
 Wir möchten genau wissen, wie lange die Suche dauert, auch wenn es hoffentlich nicht 6.5 Jahre sind. Wir möchten genau wissen, wie lange die Suche dauert, auch wenn es hoffentlich nicht 6.5 Jahre sind.
  
-Um in Python die Zeit zu stoppen, kannst du das `time` Modul verwenden. Wie lange dauert die Suche für die `Lyanna`? Wie lange für `Annina`? Weshalb der Unterschied?+Um in Python die Zeit zu stoppen, kannst du das `time` Modul verwenden. Wie lange dauert die Suche für die `Lyanna`? Wie lange für `Annina` oder `Zoraya`? Weshalb der Unterschied?
  
-<code python>+<html><bottom-editor timeout="180" zip="https://sca.ksr.ch/lib/exe/fetch.php?media=gf_informatik:programmieren_i:null79.py.zip" session="10m">
 import time import time
 +# Startzeitpunkt bestimmen
 start = time.time() start = time.time()
-# do something+ 
 +# TODO: Hier muss die Suche passieren 
 + 
 +# Endzeitpunkt bestimmen und Differenz zum Start berechnen
 elapsed = time.time() - start elapsed = time.time() - start
-print("do something took {0}s".format(elapsed)) +# Ausgabe - das ':1f' bewirkt die Darstellung mit einer Nachkommastelle 
-</code>+print(f'Vergangene Zeit: {elapsed:1f}s') 
 +</bottom-editor></html>
  
-<nodisp 2>+<nodisp 1>
 ++++Lösung| ++++Lösung|
-<code python time_algos.py>+<html><bottom-editor timeout="180" zip="https://sca.ksr.ch/lib/exe/fetch.php?media=gf_informatik:programmieren_i:null79.py.zip" session="10m">
 from null79 import names, numbers from null79 import names, numbers
 import time import time
 + 
 def linear_search(l, v): def linear_search(l, v):
     for i in range(len(l)):     for i in range(len(l)):
Zeile 167: Zeile 203:
             return i             return i
     return None     return None
 + 
 def stopwatch(name): def stopwatch(name):
     start = time.time()     start = time.time()
     index = linear_search(names, name)     index = linear_search(names, name)
     elapsed = time.time() - start     elapsed = time.time() - start
-    print("Lineare Suche für {0} dauerte {1:.1f}s".format(name, elapsed)) +    print(f'Lineare Suche für {name} dauerte {elapsed:.1f}s') 
 +  
 +stopwatch('Annina')
 stopwatch('Lyanna') stopwatch('Lyanna')
-stopwatch('Annina') +stopwatch('Zoraya') 
-</code>+</bottom-editor></html>
 ++++ ++++
 </nodisp> </nodisp>
Zeile 187: Zeile 224:
 ++++ ++++
  
-<nodisp 2>+<nodisp 1>
 ++++Code| ++++Code|
-<code python>+<html><bottom-editor zip="https://sca.ksr.ch/lib/exe/fetch.php?media=gf_informatik:programmieren_i:null79.py.zip" session="10m">
 idx = linear_search(numbers, '0791234567') idx = linear_search(numbers, '0791234567')
 print(names[idx]) print(names[idx])
-</code>+</bottom-editor></html>
 ++++ ++++
 </nodisp> </nodisp>
  
-=== Aufgabe A5: Verbesserte lineare Suche (optional) ===+=== Aufgabe A6: Verbesserte lineare Suche (optional) ===
  
 Wenn wir nach einem Namen suchen, der gar nicht in der Liste vorkommt, z.B. `Alaska`, so dauert die Suche lange, weil die ganze Liste durchsucht wird. Wenn wir nach einem Namen suchen, der gar nicht in der Liste vorkommt, z.B. `Alaska`, so dauert die Suche lange, weil die ganze Liste durchsucht wird.
Zeile 202: Zeile 239:
 Nun sind die Namen in `null79.names` *alphabetisch sortiert*. Sobald wir einen Namen antreffen, der alphabetisch nach dem gesuchten Wert liegt, können wir die Suche abbrechen. Strings können in Python mit den `>` und `<` Operatoren verglichen werden: Nun sind die Namen in `null79.names` *alphabetisch sortiert*. Sobald wir einen Namen antreffen, der alphabetisch nach dem gesuchten Wert liegt, können wir die Suche abbrechen. Strings können in Python mit den `>` und `<` Operatoren verglichen werden:
  
-<code python>+<html><bottom-editor>
 s1 = 'Alaska' s1 = 'Alaska'
 s2 = 'Alberta' s2 = 'Alberta'
Zeile 209: Zeile 246:
 else: else:
     print(s1 + ' liegt im Alphabet nach ' + s2)     print(s1 + ' liegt im Alphabet nach ' + s2)
-</code>+</bottom-editor></html>
  
 Erweitere deine Funktion `linear_search()` wie folgt: Erweitere deine Funktion `linear_search()` wie folgt:
Zeile 216: Zeile 253:
   * Ist die Liste sortiert, soll die Suche abbrechen, wenn wir im Alphabet bereits weiter sind als der gesuchte Wert.   * Ist die Liste sortiert, soll die Suche abbrechen, wenn wir im Alphabet bereits weiter sind als der gesuchte Wert.
  
-<nodisp 2>+<nodisp 1>
 ++++Lösung| ++++Lösung|
 <code python> <code python>
Zeile 230: Zeile 267:
 </nodisp> </nodisp>
  
-=== Aufgabe A6: Besserer Algorithmus? (optional) ===+=== Aufgabe A7: Besserer Algorithmus? (optional) ===
  
 Hast du eine Idee für einen besseren, sprich effizienteren Suchalgorithmus einer bereits sortierten Liste? Bespreche mit der Lehrperson und implementiere danach in Python. Hast du eine Idee für einen besseren, sprich effizienteren Suchalgorithmus einer bereits sortierten Liste? Bespreche mit der Lehrperson und implementiere danach in Python.
Zeile 237: Zeile 274:
 ---- ----
  
-Weiter zu [[gf_informatik:suchen_und_sortieren:binaersuche_2024|Binäre Suche]]+Weiter zu [[gf_informatik:suchen_und_sortieren:binaersuche|Binäre Suche]]
  
  • gf_informatik/suchen_und_sortieren.1705932076.txt.gz
  • Zuletzt geändert: 2024-01-22 14:01
  • von hof