Dateien nach "/" hochladen

Bubblesort Test für Dumme

@@ -0,0 +1,34 @@
+Sieh dir die Feldwerte der Felder mit den indexen 0 und 1 an. Der kleine Feldwert soll danach im Feld mit dem kleineren Index stehen. +
+Diesen vergleich führst du nun wiederholtn aus, nämlich immer die Indexes der Felder um die es geht um 1 erhöht. Wenn du ein mal am Ende des Arrays angekommen bist,
+fängst du wieder am Anfang an. So lange wiederholen bis in einem Durchlauf keine zwei Feldwerte Positionen getauscht haben.
+
+2 4 3 1 5
+
+2 4 3 1 5
+2 3 4 1 5
+2 3 1 4 5
+2 3 1 4 5
+
+2 3 1 4 5
+2 1 3 4 5
+2 1 3 4 5
+2 1 3 4 5
+
+1 2 3 4 5
+1 2 3 4 5
+1 2 3 4 5
+1 2 3 4 5
+
+1 2 3 4 5
+1 2 3 4 5
+1 2 3 4 5
+1 2 3 4 5
+
+SHITSLEARNING AUFGABEN BUBBLESORT
+Aufgabe 5
+Array 1: 0
+Array 2: 10
+Array 3: 4
+
+Aufgabe 6
+Worst case Array wäre das absteigende, also Array 2.

Bubblesort.py

@@ -0,0 +1,44 @@
+# Auf ein Array A mit den Werten 64, 34, 25, 12, 22, 11, 90 soll ein Bubblesort durchgeführt werden.
+# Bei jedem Durchlauf soll das Array ausgegeben werden umnd farblich markiert sein welche zwei Werte gerade verglichen werden.
+
+anzahlVergleiche = 0
+anzahlTauschungen = 0
+Array = [3,2,1,5,4]
+print ("Unsortiertes Array A:", Array)
+Länge = len(Array)
+
+
+def Aufgabe1():
+    anzahlVergleiche = 0
+    anzahlTauschungen = 0
+    for i in range(Länge):
+        for j in range(0, Länge-1):
+            print(f"Vergleich: Array[{j}] = {Array[j]} und Array[{j+1}] = {Array[j+1]}")
+            if Array[j] > Array[j+1]:
+                Array[j], Array[j+1] = Array[j+1], Array[j]
+                anzahlTauschungen += 1
+                print(f"Vertauscht: Array[{j}] = {Array[j]} und Array[{j+1}] = {Array[j+1]}")
+            anzahlVergleiche += 1
+        print()  # Neue Zeile nach jedem Durchlauf
+    print("Sortiert sieht das Array A so aus:", Array)
+    print(f"Anzahl der Vergleiche: {anzahlVergleiche}")
+    print(f"Anzahl der Tauschungen: {anzahlTauschungen}")
+
+
+def Aufgabe2():
+    anzahlVergleiche = 0
+    anzahlTauschungen = 0
+    for i in range(Länge):
+        for j in range(0, Länge-i-1):
+            print(f"Vergleich: Array[{j}] = {Array[j]} und Array[{j+1}] = {Array[j+1]}")
+            if Array[j] > Array[j+1]:
+                Array[j], Array[j+1] = Array[j+1], Array[j]
+                anzahlTauschungen += 1
+                print(f"Vertauscht: Array[{j}] = {Array[j]} und Array[{j+1}] = {Array[j+1]}")
+            anzahlVergleiche += 1
+        print()  # Neue Zeile nach jedem Durchlauf
+    print("Sortiert sieht das Array A so aus:", Array)
+    print(f"Anzahl der Vergleiche: {anzahlVergleiche}")
+    print(f"Anzahl der Tauschungen: {anzahlTauschungen}")
+
+Aufgabe2()

array.py

@@ -0,0 +1,42 @@
+
+import random
+Müllkas = [random.randint(1,10) for i in range(1,11)]
+
+
+
+def first_element(Müllkas):
+    print("Das erste Element ist:",Müllkas[0] )
+first_element(Müllkas)
+
+def last_element(Müllkas):
+    print("Das letzte Element ist:", Müllkas[9])
+last_element(Müllkas)
+
+def all_elements(Müllkas):
+    print("Alle Elemente des Arrays:") 
+    for i in range (0,9):
+        print(Müllkas[i])
+all_elements(Müllkas)
+
+def check_four(Müllkas):
+    for i in range (0,9):
+        if Müllkas[i] == 4:
+            print("Eine 4 an Stelle " + str(i) + " gefunden")
+check_four(Müllkas)
+
+def check_chosen(Müllkas):
+    chosen = int(input("Geben sie eine Zahl ein:"))
+    for i in range (0,9):
+        if Müllkas[i] == chosen:
+            print("Eine " + str(chosen)+ " an Stelle " + str(i) + " gefunden")
+check_chosen(Müllkas)
+
+def double_array(Müllkas):
+    for i in range (0,9):
+        Müllkas[i] = Müllkas[i]*2
+    print(Müllkas)
+double_array(Müllkas)
+
+def binär_code(Müllkas):
+    for i in range (0,9):
+        if Müllkas[i]==

quicksort.py

@@ -0,0 +1,32 @@
+# Ich möchte ein Quicksort-Algorithmus implementieren, der eine Liste von Zahlen sortiert. 
+# Der Algorithmus wählt ein Pivot-Element aus der Liste und teilt die anderen Elemente in drei Listen auf: 
+# diejenigen, die kleiner als das Pivot sind, diejenigen, die gleich dem Pivot sind, und diejenigen, die größer als das Pivot sind. 
+# Dann wird der Algorithmus rekursiv auf die kleineren und größeren Listen angewendet.
+
+Array = [7,2,9,4,1,8,3,6,5,0]
+
+def quicksort(Array):
+    Pivot = Array[0]
+    links = []
+    rechts = []
+    gleich = []
+    for i in range(len(Array)):
+        if i < Pivot:
+            links.append(i)
+        elif i > Pivot:
+            rechts.append(i)
+        else:
+            gleich.append(i)
+    if len(links) > 1:
+        quicksort(links)
+    if len(rechts) > 1:
+        quicksort(rechts)
+    return links + gleich + rechts
+        
+
+
+
+print(quicksort(Array))
+            
+
+