oszd meg és uralkodj algoritmus
Az “oszd meg és uralkodj” egy algoritmus-tervezési paradigma, amely egy problémát kisebb részproblémákra bont, azokat rekurzívan megoldja, majd az eredményeket egyesíti az eredeti probléma megoldásához.
A Merge Sort egy rendezési algoritmus, amely a listát kisebb részekre bontja, amíg csak egy elem marad, majd összeilleszti őket rendezett sorrendben.
def merge_sort(arr):
if len(arr) <= 1:
return arr
# Osztás
mid = len(arr) // 2
left = merge_sort(arr)
right = merge_sort(arr)
# Összefésülés
return merge(left, right)
def merge(left, right):
sorted_list =
i = j = 0
while i < len(left) and j < len(right):
if left < right:
sorted_list.append(left)
i += 1
else:
sorted_list.append(right)
j += 1
# Maradék elemek hozzáadása
sorted_list.extend(left)
sorted_list.extend(right)
return sorted_list
# Példa
arr =
sorted_arr = merge_sort(arr)
print("Rendezett lista:", sorted_arr)
Rendezett lista:
A Binary Search egy hatékony keresési algoritmus rendezett adatszerkezetekben. A keresés mindig a középső elemet hasonlítja össze a célelemmel.
def binary_search(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr == target:
return mid
elif arr < target:
left = mid + 1
else:
right = mid - 1
return -1
# Példa
arr =
target = 10
result = binary_search(arr, target)
print("Cél elem indexe:", result)
Cél elem indexe: 3
A Quick Sort egy másik rendezési algoritmus, amely a listát egy pivot elem köré rendezi, majd rekurzívan rendez kisebb és nagyobb elemeket.
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr
left =
middle =
right =
return quick_sort(left) + middle + quick_sort(right)
# Példa
arr =
sorted_arr = quick_sort(arr)
print("Rendezett lista:", sorted_arr)
Rendezett lista:
A mátrixszorzást is hatékonyabbá lehet tenni az “oszd meg és uralkodj” módszerrel. Strassen algoritmusa kisebb mátrixokra bontja a problémát, és kevesebb szorzást használ.
import numpy as np
def strassen_multiply(A, B):
if len(A) == 1:
return A * B
# Mátrixok felosztása
n = len(A) // 2
A11, A12, A21, A22 = A, A, A, A
B11, B12, B21, B22 = B, B, B, B
# Strassen-féle szorzatok
M1 = strassen_multiply(A11 + A22, B11 + B22)
M2 = strassen_multiply(A21 + A22, B11)
M3 = strassen_multiply(A11, B12 - B22)
M4 = strassen_multiply(A22, B21 - B11)
M5 = strassen_multiply(A11 + A12, B22)
M6 = strassen_multiply(A21 - A11, B11 + B12)
M7 = strassen_multiply(A12 - A22, B21 + B22)
# Eredmény mátrix összeállítása
C11 = M1 + M4 - M5 + M7
C12 = M3 + M5
C21 = M2 + M4
C22 = M1 - M2 + M3 + M6
# Mátrix összeillesztése
C = np.vstack((np.hstack((C11, C12)), np.hstack((C21, C22))))
return C
# Példa
A = np.array(, ])
B = np.array(, ])
C = strassen_multiply(A, B)
print("Mátrix szorzat eredménye:\n", C)
Mátrix szorzat eredménye: ]
Az “oszd meg és uralkodj” algoritmusok hatékonyan alkalmazhatók számos problémára, például rendezésre, keresésre és mátrixműveletekre. Ez a megközelítés a kisebb részproblémák újrafelhasználásával csökkenti a számítási költségeket, miközben rekurzív természetével egyszerűsíti a megvalósítást.