ما هو التفكير الخوارزمي؟

التفكير الخوارزمي هو طريقة منظمة لحل المشاكل من خلال تقسيمها إلى خطوات منطقية.

مكونات التفكير الخوارزمي:

• التفكيك (Decomposition): تقسيم المشكلة إلى أجزاء أصغر
• التعرف على الأنماط (Pattern Recognition): إيجاد أوجه التشابه
• التجريد (Abstraction): التركيز على التفاصيل المهمة
• الخوارزميات (Algorithms): تصميم خطوات الحل

خطوات تحليل المشكلة:

1. قراءة المشكلة بعناية
2. تحديد المدخلات والمخرجات
3. تحديد القيود والشروط
4. التفكير في حالات خاصة
5. تصميم خطة الحل

أنواع التعقيد:

• Time Complexity: الوقت المستغرق
• Space Complexity: المساحة المستخدمة

Big O Notation:

# O(1) - Constant
def get_first(arr):
    return arr[0]

# O(n) - Linear
def find_max(arr):
    max_val = arr[0]
    for num in arr:
        if num > max_val:
            max_val = num
    return max_val

# O(n²) - Quadratic
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

استخدام المصفوفات:

# مثال: إيجاد مجموع عناصر المصفوفة
def sum_array(arr):
    total = 0
    for num in arr:
        total += num
    return total

# مثال: إيجاد أكبر عنصر
def find_max(arr):
    if not arr:
        return None
    max_val = arr[0]
    for num in arr[1:]:
        if num > max_val:
            max_val = num
    return max_val

Linked List:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None
    
    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

Stack (LIFO):

stack = []
stack.append(1)  # push
stack.append(2)
stack.pop()      # pop - returns 2

Queue (FIFO):

from collections import deque
queue = deque()
queue.append(1)  # enqueue
queue.append(2)
queue.popleft()  # dequeue - returns 1

Binary Tree:

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def inorder_traversal(root):
    if root:
        inorder_traversal(root.left)
        print(root.val)
        inorder_traversal(root.right)

Graph Representation:

# Adjacency List
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D'],
    'C': ['A'],
    'D': ['B']
}

Linear Search - O(n):

def linear_search(arr, target):
    for i, num in enumerate(arr):
        if num == target:
            return i
    return -1

Binary Search - O(log n):

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

مقدمة:

خوارزميات الترتيب تستخدم لترتيب البيانات بترتيب معين (تصاعدي أو تنازلي).

• Bubble Sort: O(n²)
• Quick Sort: O(n log n) average
• Merge Sort: O(n log n)
• Insertion Sort: O(n²)

Bubble Sort - O(n²):

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

Quick Sort - O(n log n):

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

Merge Sort - O(n log n):

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

Hash Table:

# استخدام Dictionary في Python
hash_map = {}
hash_map['key1'] = 'value1'
hash_map['key2'] = 'value2'

# البحث O(1)
value = hash_map.get('key1')

Dynamic Programming:

# مثال: Fibonacci
def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 2:
        return 1
    memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo)
    return memo[n]

Greedy Algorithms:

الخوارزميات الجشعة تختار الحل الأمثل محلياً في كل خطوة.

# مثال: مشكلة العملات
def coin_change(coins, amount):
    coins.sort(reverse=True)
    count = 0
    for coin in coins:
        count += amount // coin
        amount %= coin
    return count

Backtracking:

def solve_n_queens(n):
    def is_safe(row, col, board):
        # التحقق من الأمان
        pass
    
    def backtrack(row, board):
        if row == n:
            return True
        for col in range(n):
            if is_safe(row, col, board):
                board[row] = col
                if backtrack(row + 1, board):
                    return True
                board[row] = -1
        return False

DFS (Depth-First Search):

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start)
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

BFS (Breadth-First Search):

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)
    while queue:
        node = queue.popleft()
        print(node)
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

Binary Search Tree:

class BST:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
    
    def insert(self, val):
        if val < self.val:
            if self.left:
                self.left.insert(val)
            else:
                self.left = BST(val)
        else:
            if self.right:
                self.right.insert(val)
            else:
                self.right = BST(val)

Heap:

import heapq

heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 1)
heapq.heappush(heap, 2)
min_val = heapq.heappop(heap)  # 1

String Algorithms:

# البحث في النص
def find_substring(text, pattern):
    n, m = len(text), len(pattern)
    for i in range(n - m + 1):
        if text[i:i+m] == pattern:
            return i
    return -1

Two Pointers:

# مثال: إيجاد زوجين مجموعهما يساوي target
def two_sum(arr, target):
    left, right = 0, len(arr) - 1
    while left < right:
        current_sum = arr[left] + arr[right]
        if current_sum == target:
            return [left, right]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []

Sliding Window:

# مثال: أطول subarray بدون تكرار
def longest_substring(s):
    char_set = set()
    left = 0
    max_len = 0
    for right in range(len(s)):
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        char_set.add(s[right])
        max_len = max(max_len, right - left + 1)
    return max_len

مشاكل رياضية:

# GCD
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

# Prime Check
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

Bit Operations:

# AND: &
# OR: |
# XOR: ^
# NOT: ~
# Left Shift: <<
# Right Shift: >>

# مثال: عدد البتات
def count_bits(n):
    count = 0
    while n:
        count += n & 1
        n >>= 1
    return count

خوارزميات متقدمة:

• Dijkstra's Algorithm
• Floyd-Warshall
• Kruskal's Algorithm
• Topological Sort

نصائح للممارسة:

• ابدأ بمشاكل سهلة
• حل مشاكل متنوعة
• راجع الحلول بعد الحل
• مارس بانتظام

مشروع تطبيقي:

بناء نظام إدارة مهام يستخدم:

• Data Structures (Lists, Trees)
• Sorting Algorithms
• Search Algorithms
• Graph Algorithms