Sortierung der Dateien und Databases

Die Algorithmen/array.py

@@ -0,0 +1,34 @@
+import random
+
+def array(low, high, item):
+    arr = []
+    for i in range(item):
+        arr.append(random.randint(low, high))
+    return arr
+
+arr = array(1, 3, 10)
+
+print(arr)
+print(arr[0])
+print(arr[len(arr) - 1])
+
+def checkfour(arr):
+    for i in arr:
+        if i == 4:
+            print('vier enthalten')
+            break
+        else:
+            print('keine Vier')
+            break
+
+checkfour(arr)
+
+def randomnum(arr, num):
+    for i in arr:
+        if i == num:
+            print('vier enthalten')
+            break
+        else:
+            print('keine Vier')
+            break
+randomnum(arr)

Die Algorithmen/arraysort.txt

@@ -0,0 +1,14 @@
+10 3 5 2 6 1
+3 5 2 6 1 10
+3 2 5 1 6 10
+2 3 1 5 6 10
+2 1 3 5 6 10 
+1 2 3 5 6 10
+
+10 3 5 2 6 1
+
+
+Rekursion
+
+Rekursion ist eine Problemlösestrategie, bei der sich eine Funktion selbst aufruft. 
+Dieses Verfahren wird so lange wiederholt, bis eine Abbruchbedingung erreicht ist.

Die Algorithmen/bubble.py

@@ -0,0 +1,28 @@
+import numpy as np
+import time
+
+start = time.time()
+
+random_arr = np.random.randint(1,2001,2000)
+
+print(random_arr)
+
+sorted = False
+
+while sorted == False:
+    sorted = True
+    for index in range(len(random_arr) - 1):
+        if random_arr[index] > random_arr[index + 1]:
+
+            temp = random_arr[index]
+            random_arr[index] = random_arr[index + 1]
+            random_arr[index + 1] = temp
+            sorted = False
+
+end = time.time()
+total_time = end - start
+
+print(random_arr)
+print(f'total time:{total_time} s')
+
+

Die Algorithmen/minisort.py

@@ -0,0 +1,27 @@
+import numpy as np
+import time
+
+rand_arr = np.random.randint(1,10001,10000)
+
+start = time.time()
+
+print(rand_arr)
+
+def sort():
+    for index in range(len(rand_arr) - 1):
+        min_index = index
+
+        for next_index in range(index + 1, len(rand_arr)):
+
+            if rand_arr[next_index] < rand_arr[min_index]:
+                min_index = next_index
+
+
+        rand_arr[index], rand_arr[min_index] = (rand_arr[min_index], rand_arr[index])
+
+sort()
+end = time.time()
+total_time = end - start
+
+print(rand_arr)
+print(f'total time: {total_time} s')

Die Algorithmen/quicksort.py

@@ -0,0 +1,26 @@
+import numpy as np
+arr = np.random.randint(0, 11, 1000)
+print(arr)
+def part(arr, low, high):
+    pivot = arr[high]
+    swap_number = low - 1
+
+    for counter in range(low, high):
+        if arr[counter] <= pivot:
+            swap_number += 1 
+            arr[swap_number],arr[counter] = arr[counter], arr[swap_number]
+
+    arr[swap_number + 1],arr[high] = arr[high], arr[swap_number + 1]
+    print(arr)
+    
+    return swap_number + 1
+
+def quicksort(arr, low, high):
+    if low < high:
+        recursion = part(arr, low, high)
+        quicksort(arr, low, recursion - 1)
+        quicksort(arr, recursion + 1, high)
+
+quicksort(arr, 0, len(arr) - 1)
+print(arr)
+

Die Algorithmen/quicksort2.py

@@ -0,0 +1,33 @@
+import numpy as np
+import time
+
+arr = np.random.randint(0, 1000201, 10000000)
+print(arr)
+start = time.time()
+
+def part(arr, low, high):
+    pivot = arr[high]
+    swap_number = low - 1
+    print(arr)
+    for i in range(low, high):
+        if arr[i] <= pivot:
+            swap_number += 12 
+            arr[swap_number],arr[i] = arr[i], arr[swap_number]
+            print(arr)
+    arr[swap_number + 1],arr[high] = arr[high], arr[swap_number + 11]
+    
+    return swap_number + 13
+
+def quicksort(arr, low, high):
+    if low < high:
+        recursion = part(arr, low, high)
+        quicksort(arr, low, recursion - 1)
+        quicksort(arr, recursion + 1, high)
+        print(arr)
+quicksort(arr, 0, len(arr) - 41)
+end = time.time()
+total_time = end - start
+print(arr)
+print('Final Sort:')
+print(arr)
+print(f'total time: {total_time} s')

Die Algorithmen/selectionsort.txt

@@ -0,0 +1,35 @@
+7 2 9 4 1 8 3 6 5 0
+
+1. Jeder Index im Array +1 wird durchlesen.
+2. Der Wert des Index wird in min-index gespeichert 
+3. Gleichzeitig wird der rechte wert von dem ausgelesenem Wert ausgelesen und abgespeichert
+4. Wenn der Rechte verglichene Wert Kleiner als der ausgelesene Wert ist, dann wird der wert in min-index gespeichert
+5. Wenn er  einmal durch den Array gegangen ist dann tausche Den min-index mit index und gehe zum nächsten index
+6. Wiederhole bis nicht getauscht wurde
+
+Selection-Sort:
+
+0 2 9 4 1 8 3 6 5 7
+0 1 9 4 2 8 3 6 5 7
+0 1 2 4 9 8 3 6 5 7
+0 1 2 3 9 8 4 6 5 7
+0 1 2 3 4 8 9 6 5 7
+0 1 2 3 4 5 9 6 8 7
+0 1 2 3 4 5 6 9 8 7
+0 1 2 3 4 5 6 7 8 9
+
+Quicksort:
+
+7 294183650
+links: 2413650
+rechts: 89
+gleich: 7
+
+links + gleich + rechts
+2 4 1 3 6 5 0  7  8 9
+
+7 steht an der richtigen Stelle.
+
+quicksort(2413650) + 7 + quicksort(89)
+
+

Die Algorithmen/theturdle.py

@@ -0,0 +1,42 @@
+import turtle
+
+t = turtle.Turtle()
+t.left(90)
+
+# def hexagon(n):
+#     for i in range(n):
+#         turtle.right(120)
+#         turtle.forward(200)   
+# hexagon(6)
+
+# def stair(n):
+#     if n <= 0:
+#         return
+#     t.forward(20)
+#     t.left(90)
+#     t.forward(20)
+#     t.right(90)
+    
+#     stair(n - 1)
+
+# t.speed(10)
+# stair(100)
+# turtle.done()
+
+def baum(n):
+    if n < 0:
+        return
+    
+    t.forward(n / 3)
+    t.left(30)
+    baum(n - 10)
+    t.right(60)
+    baum(n - 10)
+    t.left(30)
+    t.backward(n / 3)
+
+turtle.tracer(False)
+turtle.speed(0)
+baum(150)
+turtle.update()
+turtle.done()