Bilgisayar Bilimleri Sınav Notlarım: Veri Yapılarından Dağıtık Sistemlere

Bu sayfa bir yazıdan çok bir depo. Bilimsel değerlendirme sınavına çalışırken dağınık duran notlarımı, kod örneklerini, karşılaştırma tablolarını ve en önemlisi “neden böyle?” sorularının cevaplarını tek yerde topladım. Amacım listeyi ezberlemek değil, her maddenin arkasındaki gerekçeyi cümleye dökebilmekti — çünkü sınavlar tanımı değil gerekçeyi soruyor.

Bölüm 1 — Yazılım Geliştirme Süreçleri

SDLC (Software Development Life Cycle)

Bir yazılımın fikir aşamasından kullanımdan kaldırılmasına kadar geçen tüm süreçleri kapsayan modeldir. Amacı; süreci adımlara bölerek kaliteyi artırmak, maliyeti düşürmek ve süreci yönetilebilir kılmaktır.

flowchart LR
    A[Planlama] --> B[Analiz] --> C[Tasarım] --> D[Geliştirme] --> E[Test] --> F[Dağıtım] --> G[Bakım]

Waterfall ve Scrum

Scrum rolleri: Product Owner (ürün sahibi — backlog’u önceliklendirir), Scrum Master (süreci kolaylaştırır, engelleri kaldırır), Development Team.

Scrum etkinlikleri: Sprint Planning, Daily Scrum (günlük 15 dk), Sprint Review, Sprint Retrospective.

Fonksiyonel ve Fonksiyonel Olmayan Gereksinimler

Bölüm 2 — Veri Yapıları

Array (Dizi)

Elemanların ardışık bellekte tutulduğu veri yapısıdır. Boyutu genellikle sabittir.

Linked List (Bağlı Liste)

Her elemanın (node) veriyle birlikte bir sonraki node’un referansını tuttuğu dinamik yapıdır. Bellekte ardışık durmak zorunda değildir.

• Arama / belirli node’a erişim: O(n)
• Bilinen bir node’dan ekleme/silme: O(1) (sadece referanslar değişir)
• Türleri: tek yönlü (singly), çift yönlü (doubly), dairesel (circular)

Stack ve Queue

flowchart LR
    subgraph Stack [Stack - LIFO]
        direction TB
        S3[3 - en son giren, ilk çıkar] --- S2[2] --- S1[1]
    end
    subgraph Queue [Queue - FIFO]
        direction LR
        Q1[1 - ilk giren, ilk çıkar] --- Q2[2] --- Q3[3]
    end

Stack uygulaması: parantez denetimi klasik soru

Stack’in “neden LIFO?” sorusunun en somut cevabı bu. Bir ifadedeki parantezlerin doğru kapanıp kapanmadığını kontrol ederken, en son açılan parantezin ilk kapanması gerekir — yani tam olarak yığın davranışı.

def parantez_dogru_mu(s):
    stack = []
    eslesme = {
        ')': '(',
        ']': '[',
        '}': '{'
    }

    for ch in s:
        if ch in "([{":
            stack.append(ch)          # açılış → yığına at

        elif ch in ")]}":
            if not stack:             # kapanış geldi ama açık parantez yok
                return False

            if stack.pop() != eslesme[ch]:   # en son açılanla türü uyuşmuyor
                return False

    return len(stack) == 0            # sonda yığın boşsa hepsi kapanmış


print(parantez_dogru_mu("{[()]}"))   # True
print(parantez_dogru_mu("{[(])}"))   # False
print(parantez_dogru_mu("([]{})"))   # True
print(parantez_dogru_mu("([)]"))     # False

Üç ayrı False durumu var — sınavda “hangi durumda neden reddedilir?” diye sorulabiliyor:

"([)]" adım adım — sezgiye ters gelen, en öğretici örnek:

Parantez sayıları eşit ((×1, )×1, [×1, ]×1) ama iç içe geçme sırası bozuk. Sadece sayarak çözmeye çalışan bir yaklaşım bunu kaçırır; stack yakalar.

Hash Table

Anahtar-değer (key-value) mantığıyla çalışır. Bir hash fonksiyonu anahtarı dizide bir indekse dönüştürür.

• Ortalama arama / ekleme / silme: O(1), en kötü durum: O(n)
• Collision (çakışma): İki farklı anahtar aynı indekse düşerse oluşur. Çözümler: chaining (aynı hücrede bağlı liste) veya open addressing (bir sonraki boş hücreyi arama).

Tree (Ağaç) ve Binary Search Tree (BST)

Hiyerarşik veri yapısıdır. En üstteki düğüm root (kök), çocuğu olmayan düğümler leaf (yaprak)’tır.

BST kuralı: Sol alt ağaç < node < Sağ alt ağaç

• Dengeli BST’de arama/ekleme/silme: O(log n)
• Dengesizleşirse (tek kola uzarsa): O(n)

Terimler

• Binary Tree: Her düğümün en fazla 2 çocuğu vardır.
• Binary Search Tree (BST): Binary tree + sıralama kuralı (sol < kök < sağ).
• Balanced Tree (Dengeli Ağaç): Sol ve sağ yüksekliklerin farkı sınırlıdır → AVL, Red-Black Tree. Amaç yüksekliği \(\log n\)‘de tutmaktır.

Verilen sayıları ağaca çevirme (BST kurma) klasik soru

Kural: İlk sayı kök olur. Sonraki her sayı kökten başlar; küçükse sola, büyükse sağa iner ve boş bulduğu yere yerleşir. Eşit değerler genelde yok sayılır.

Girdi: 8, 3, 10, 1, 6, 14, 4, 7, 13

Oluşan ağaç:

              8
          /       \
        3          10
      /   \          \
    1      6          14
          / \        /
         4   7     13

flowchart TD
    A((8)) --> B((3))
    A --> C((10))
    B --> D((1))
    B --> E((6))
    E --> F((4))
    E --> G((7))
    C --> H((14))
    H --> I((13))

Aynı sayıdan birden fazla gelirse ne olur? tuzak

Kısa cevap: Klasik BST tanımında eklenmez. Standart BST kuralı sol < kök < sağ şeklinde kesin eşitsizlik kullanır; eşitlik durumu tanımsızdır. Bu yüzden cevap hangi stratejiyi seçtiğinize bağlıdır.

Aşağıdaki üç yöntemin hepsi, yukarıdaki ağaca iki tane daha 3 geldiği varsayımıyla anlatılıyor.

if value < root.value:   root.left  = insert(root.left, value)
elif value > root.value: root.right = insert(root.right, value)
# eşitse: hiçbir şey yapma → sessizce yok sayılır

class Node:
    def __init__(self, value):
        self.value = value
        self.count = 1          # ← kaç kez eklendi
        self.left = self.right = None

def insert(root, value):
    if root is None:            return Node(value)
    if value < root.value:      root.left  = insert(root.left, value)
    elif value > root.value:    root.right = insert(root.right, value)
    else:                       root.count += 1     # ← tekrar
    return root

8'de: 3 < 8      → sola
3'te: 3 < 3 değil → SAĞA
6'da: 3 < 6      → sola
4'te: 3 < 4      → sola → boş! Buraya yerleşir.

              8
          /       \
        3          10
      /   \          \
    1      6          14
          / \        /
         4   7     13
        /
      3(2)                ← ikinci 3
        \
        3(3)              ← üçüncü 3

Ağaç Dolaşma (Tree Traversal) — DFS ve BFS sık sorulur

Ağacın tüm düğümlerini gezme yöntemleridir. İkiye ayrılır:

• DFS (Depth-First Search — Derinlik Öncelikli): Bir kolun sonuna kadar iner, sonra geri döner. Stack veya recursion kullanır. Üç çeşidi vardır: Preorder, Inorder, Postorder.
• BFS (Breadth-First Search — Genişlik Öncelikli): Ağacı seviye seviye gezer. Queue (kuyruk) kullanır. Ağaçlardaki adı Level-order traversal‘dır.

DFS’in üç çeşidi — aralarındaki tek fark, kökün ne zaman yazıldığıdır. Sol her zaman sağdan önce gelir.

Yukarıdaki 8, 3, 10, 1, 6, 14, 4, 7, 13 ağacı için çıktılar (ezberlemeyin, elle çıkarın):

Preorder    (Kök-Sol-Sağ) : 8, 3, 1, 6, 4, 7, 10, 14, 13
Inorder     (Sol-Kök-Sağ) : 1, 3, 4, 6, 7, 8, 10, 13, 14   ← SIRALI!
Postorder   (Sol-Sağ-Kök) : 1, 4, 7, 6, 3, 13, 14, 10, 8
Level-order (BFS)         : 8, 3, 10, 1, 6, 14, 4, 7, 13

Dolaşmayı elle çıkarmanın dört yolu

Aşağıdaki dört yöntem de aynı sonucu verir; sınavda hangisi hızınıza uyuyorsa onu kullanın.

            ┌─── 1. geçiş: düğümün SOLUNDAN (aşağı inerken)  → PREORDER'a yaz
            │
        ╭───┴───╮
   ─────┤  DÜĞÜM ├─────
        ╰───┬───╯      └─ 3. geçiş: düğümün SAĞINDAN (yukarı çıkarken) → POSTORDER'a yaz
            │
            └─── 2. geçiş: düğümün ALTINDAN (sol bitip sağa geçerken) → INORDER'a yaz

   PREORDER (Kök-Sol-Sağ)        INORDER (Sol-Kök-Sağ)        POSTORDER (Sol-Sağ-Kök)

          8⁽¹⁾                          8⁽⁶⁾                          8⁽⁹⁾
       /       \                     /       \                     /       \
    3⁽²⁾       10⁽⁷⁾              3⁽²⁾       10⁽⁷⁾              3⁽⁵⁾       10⁽⁸⁾
    /   \         \               /   \         \               /   \         \
 1⁽³⁾   6⁽⁴⁾      14⁽⁸⁾        1⁽¹⁾   6⁽⁴⁾      14⁽⁹⁾        1⁽¹⁾   6⁽⁴⁾      14⁽⁷⁾
        / \       /                   / \       /                   / \       /
     4⁽⁵⁾ 7⁽⁶⁾  13⁽⁹⁾              4⁽³⁾ 7⁽⁵⁾  13⁽⁸⁾              4⁽²⁾ 7⁽³⁾  13⁽⁶⁾

  Kök hep EN BAŞTA (1)          Kök hep ORTADA (6)            Kök hep EN SONDA (9)
  → yukarıdan aşağı             → soldan sağa                 → aşağıdan yukarı

def preorder(n):        def inorder(n):         def postorder(n):
    if n is None: return    if n is None: return    if n is None: return
    yaz(n)          # ①    inorder(n.left)         postorder(n.left)
    preorder(n.left)        yaz(n)          # ②    postorder(n.right)
    preorder(n.right)       inorder(n.right)        yaz(n)          # ③

pre(8)   → YAZ 8                              çıktı: 8
  pre(3)   → YAZ 3                            çıktı: 8,3
    pre(1)   → YAZ 1                          çıktı: 8,3,1
      pre(None) → dön ;  pre(None) → dön
    ← 1 bitti
    pre(6)   → YAZ 6                          çıktı: 8,3,1,6
      pre(4)   → YAZ 4                        çıktı: 8,3,1,6,4
      pre(7)   → YAZ 7                        çıktı: 8,3,1,6,4,7
    ← 6 bitti
  ← 3 bitti
  pre(10)  → YAZ 10                           çıktı: ...,10
    pre(None) → dön                (10'un solu yok)
    pre(14)  → YAZ 14                         çıktı: ...,14
      pre(13)  → YAZ 13                       çıktı: ...,13

in(8)
  in(3)
    in(1) → solu yok → YAZ 1 → sağı yok            çıktı: 1
    YAZ 3                                          çıktı: 1,3
    in(6)
      in(4) → YAZ 4                                çıktı: 1,3,4
      YAZ 6                                        çıktı: 1,3,4,6
      in(7) → YAZ 7                                çıktı: 1,3,4,6,7
  YAZ 8                            ← kök tam ortada  çıktı: ...,8
  in(10)
    solu yok → YAZ 10                              çıktı: ...,10
    in(14)
      in(13) → YAZ 13                              çıktı: ...,13
      YAZ 14                                       çıktı: ...,14

post(8)
  post(3)
    post(1)  → YAZ 1                               çıktı: 1
    post(6)
      post(4) → YAZ 4                              çıktı: 1,4
      post(7) → YAZ 7                              çıktı: 1,4,7
      YAZ 6                                        çıktı: 1,4,7,6
    YAZ 3                                          çıktı: 1,4,7,6,3
  post(10)
    post(14)
      post(13) → YAZ 13                            çıktı: ...,13
      YAZ 14                                       çıktı: ...,14
    YAZ 10                                         çıktı: ...,10
  YAZ 8                            ← kök EN SONDA   çıktı: ...,8

Seviye 0:  8
Seviye 1:  3, 10
Seviye 2:  1, 6, 14
Seviye 3:  4, 7, 13

Kendini test et

5, 3, 8, 2, 4, 7, 9 sırasıyla bir BST kurun ve dört dolaşmayı yazın.

        5
      /   \
     3     8
    / \   / \
   2   4 7   9

Preorder  : 5, 3, 2, 4, 8, 7, 9
Inorder   : 2, 3, 4, 5, 7, 8, 9     ← sıralı
Postorder : 2, 4, 3, 7, 9, 8, 5
BFS       : 5, 3, 8, 2, 4, 7, 9

Hangisi ne zaman kullanılır?

Karmaşıklık: Hepsi zamanda O(n) — her düğüme bir kez uğranır. Bellekte DFS O(h) (h = yükseklik, recursion stack; en kötü O(n)), BFS O(w) (w = en geniş seviyedeki düğüm sayısı; en kötü O(n)).

İfade ağacı (Expression Tree)

(3 + 5) * 2 ifadesinin ağacı:

        *
       / \
      +   2
     / \
    3   5

• Preorder → prefix: * + 3 5 2
• Inorder → infix: 3 + 5 * 2
• Postorder → postfix (RPN): 3 5 + 2 *

Python referans kodu

from collections import deque

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

# --- Verilen sayıları BST'ye çevirme ---
def insert(root, value):
    if root is None:                 # boş yer bulundu → yeni düğüm
        return Node(value)
    if value < root.value:
        root.left = insert(root.left, value)
    elif value > root.value:
        root.right = insert(root.right, value)
    return root                      # eşit değer → yok say

def build_bst(numbers):
    root = None
    for n in numbers:
        root = insert(root, n)
    return root

# --- DFS: üç dolaşma (recursive) ---
def preorder(node, out):             # Kök - Sol - Sağ
    if node is None: return
    out.append(node.value)
    preorder(node.left, out)
    preorder(node.right, out)

def inorder(node, out):              # Sol - Kök - Sağ  (BST'de sıralı çıkar)
    if node is None: return
    inorder(node.left, out)
    out.append(node.value)
    inorder(node.right, out)

def postorder(node, out):            # Sol - Sağ - Kök
    if node is None: return
    postorder(node.left, out)
    postorder(node.right, out)
    out.append(node.value)

# --- DFS: stack ile (recursion'sız, preorder sırası) ---
def dfs_iterative(root):
    if root is None: return []
    out, stack = [], [root]
    while stack:
        node = stack.pop()
        out.append(node.value)
        if node.right: stack.append(node.right)  # önce sağ eklenir ki
        if node.left:  stack.append(node.left)   # sol önce işlensin
    return out

# --- Inorder'ın iteratif hali (klasik mülakat sorusu) ---
def inorder_iterative(root):
    out, stack, cur = [], [], root
    while stack or cur:
        while cur:                   # sola sonuna kadar in, yolu stack'e yaz
            stack.append(cur)
            cur = cur.left
        cur = stack.pop()            # en soldaki düğüm
        out.append(cur.value)        # yaz
        cur = cur.right              # sağa geç
    return out

# --- BFS: queue ile (level-order) ---
def level_order(root):
    if root is None: return []
    out, q = [], deque([root])
    while q:
        node = q.popleft()
        out.append(node.value)
        if node.left:  q.append(node.left)
        if node.right: q.append(node.right)
    return out

# --- BST'de arama: O(log n) (dengeliyse) ---
def search(root, target):
    while root:
        if target == root.value: return True
        root = root.left if target < root.value else root.right
    return False

# --- Ağacın yüksekliği ---
def height(node):
    if node is None: return -1       # yaprak yüksekliği 0 olsun diye -1
    return 1 + max(height(node.left), height(node.right))

# --- Kullanım ---
sayilar = [8, 3, 10, 1, 6, 14, 4, 7, 13]
root = build_bst(sayilar)

out = []; preorder(root, out);  print("Preorder :", out)   # [8,3,1,6,4,7,10,14,13]
out = []; inorder(root, out);   print("Inorder  :", out)   # [1,3,4,6,7,8,10,13,14]
out = []; postorder(root, out); print("Postorder:", out)   # [1,4,7,6,3,13,14,10,8]
print("BFS      :", level_order(root))                     # [8,3,10,1,6,14,4,7,13]
print("Yükseklik:", height(root))                          # 3
print("6 var mı?:", search(root, 6))                       # True

Heap

Öncelik kuyruğu (Priority Queue) oluşturmak için kullanılan ağaç tabanlı yapıdır.

• Min Heap: En küçük eleman root’tadır.
• Max Heap: En büyük eleman root’tadır.
• Ekleme/çıkarma: O(log n); root’a bakma: O(1). Heap Sort algoritmasının temelidir.

Graph (Graf)

Düğümler (vertex) ve kenarlardan (edge) oluşur; yönlü (directed) veya yönsüz (undirected) olabilir. Sosyal ağlar ve harita/rota uygulamalarında kullanılır.

• BFS: Genişlik öncelikli; kuyruk kullanır. Ağırlıksız grafta en kısa yolu bulur.
• DFS: Derinlik öncelikli; stack veya recursion kullanır. Döngü tespiti, topolojik sıralama, bağlı bileşen bulmada kullanılır.
• Her ikisi de O(V + E) (V = düğüm, E = kenar sayısı).
• Ağaçtan tek farkı: Grafta döngü olabileceği için visited seti tutulmak zorundadır; yoksa sonsuz döngüye girilir.

# Graf üzerinde BFS ve DFS (komşuluk listesi: {"A": ["B", "C"], ...})
from collections import deque

def bfs(graph, start):
    visited, order, q = {start}, [], deque([start])
    while q:
        node = q.popleft()
        order.append(node)
        for komsu in graph[node]:
            if komsu not in visited:
                visited.add(komsu)
                q.append(komsu)
    return order

def dfs(graph, node, visited=None, order=None):
    if visited is None: visited, order = set(), []
    visited.add(node)
    order.append(node)
    for komsu in graph[node]:
        if komsu not in visited:
            dfs(graph, komsu, visited, order)
    return order

Bölüm 3 — Algoritmalar

Algoritma Karmaşıklığı

• Time Complexity: Girdi boyutu (n) arttıkça çalışma süresinin nasıl değiştiğini ifade eder. Örn: \(O(n^2)\) → girdi 2 katına çıkarsa süre yaklaşık 4 katına çıkar.
• Space Complexity: Girdi büyüdükçe ihtiyaç duyulan ek bellek miktarının değişimidir.

Big-O karşılaştırması (iyiden kötüye)

O(1)        → sabit          (hash table erişimi)
O(log n)    → logaritmik     (binary search)
O(n)        → doğrusal       (linear search)
O(n log n)  → linearitmik    (merge sort, quick sort ortalama)
O(n²)       → karesel        (bubble, selection, insertion sort)
O(2ⁿ)       → üstel          (naif fibonacci recursion)
O(n!)       → faktöriyel     (brute-force gezgin satıcı)

Algoritma Gösterim Şekilleri

• Pseudocode (Sözde Kod): Adımları programlama dilinden bağımsız, konuşma diline yakın ifade etme.
• Flowchart (Akış Şeması): Adımları geometrik şekiller ve oklarla görsel ifade etme. Elips = başla/bitir, dikdörtgen = işlem, baklava dilimi = karar, paralelkenar = girdi/çıktı.

Arama Algoritmaları

• Linear Search: Elemanları sırayla tek tek kontrol eder. O(n). Sırasız listelerde de çalışır.
• Binary Search: Yalnızca sıralı listelerde çalışır. Ortaya bakar; aranan küçükse sola, büyükse sağa devam eder. O(log n).

Sıralama Algoritmaları

• Bubble Sort: Komşu elemanları ikili karşılaştırır, yanlış sıradaysa yer değiştirir; liste sıralanana kadar tekrar eder.
• Selection Sort: Her iterasyonda kalanlar arasından en küçüğü bulup doğru konuma koyar.
• Insertion Sort: Elemanları tek tek alıp sıralı bölümde doğru yere yerleştirir.
• Merge Sort: Listeyi ikiye böler, parçaları sıralar, birleştirir.
• Quick Sort: Pivot seçer; küçükler sola, büyükler sağa. Alt parçalara aynı işlemi uygular. En kötü durumu (O(n²)) pivot hep en küçük/en büyük seçilirse oluşur.

flowchart TD
    A["[38, 27, 43, 3]"] --> B["[38, 27]"]
    A --> C["[43, 3]"]
    B --> D["[38]"]
    B --> E["[27]"]
    C --> F["[43]"]
    C --> G["[3]"]
    D --> H["[27, 38]"]
    E --> H
    F --> I["[3, 43]"]
    G --> I
    H --> J["[3, 27, 38, 43]"]
    I --> J

Merge Sort: böl → sırala → birleştir.

Recursion (Özyineleme)

Fonksiyonun kendini çağırmasıdır. Mutlaka bir base case (temel durum) olmalıdır; yoksa sonsuz döngü oluşur ve stack overflow ile biter. Klasik örnekler: faktöriyel, Fibonacci, ağaç dolaşmaları.

Bölüm 4 — Sayı Sistemleri, Bit İşlemleri ve Mantık Kapıları

Sayı Sistemleri

1011₂ = 1·8 + 0·4 + 1·2 + 1·1 = 11₁₀
110101₂ = 32 + 16 + 4 + 1 = 53₁₀

25 / 2 = 12  kalan 1
12 / 2 = 6   kalan 0
6  / 2 = 3   kalan 0
3  / 2 = 1   kalan 1
1  / 2 = 0   kalan 1
Tersten oku → 25₁₀ = 11001₂

10111100₂ → 1011 | 1100 → B | C → BC₁₆
2F₁₆ → 0010 | 1111 → 00101111₂

Two’s Complement (İkiye Tümleyen) sık sorulur

Bilgisayarlar negatif tamsayıları two’s complement ile tutar.

Hesaplama: Tüm bitleri ters çevir (one’s complement) → 1 ekle.

8 bitte -5:
 5  = 00000101
ters = 11111010   (one's complement)
+1  = 11111011   → -5

• En soldaki bit (MSB) işaret göstergesidir: 1 ise negatif.
• n bitin aralığı: \(-2^{n-1} \ldots 2^{n-1}-1\) — 8 bit için −128 … +127. Negatif taraf bir fazladır.
• Geri çevirmek için aynı işlem tekrar uygulanır (ters çevir + 1).
• Doğrulama: 5 + (-5) = 00000101 + 11111011 = 1 00000000 → taşan bit atılır, sonuç 0 ✓

Bitwise (Bit Düzeyi) Operatörler

12 = 1100, 10 = 1010 üzerinden:

Klasik bit soruları

# 1) Tek mi çift mi? — son bit 1 ise tektir
def tek_mi(n):
    return n & 1 == 1

# 2) 2'nin kuvveti mi? — 2^k'nin binary'sinde tek bir 1 vardır (1000...),
#    n-1 o biti söndürüp sağını 1 yapar (0111...) → AND'leri 0 olur
def ikinin_kuvveti(n):
    return n > 0 and (n & (n - 1)) == 0
# 8 = 1000, 7 = 0111 → 8 & 7 = 0 ✓   |   6 = 110, 5 = 101 → 6 & 5 = 100 ≠ 0 ✗

# 3) XOR ile swap — geçici değişken kullanmadan
a, b = 5, 9
a = a ^ b
b = a ^ b    # (a^b)^b = a
a = a ^ b    # (a^b)^a = b

# 4) i'inci biti oku / set et / temizle / tersle (i sağdan, 0'dan başlar)
oku     = (n >> i) & 1
setle   = n | (1 << i)
temizle = n & ~(1 << i)
tersle  = n ^ (1 << i)

# 5) 1 bitlerini sayma (Brian Kernighan): her adım en sağdaki 1'i söndürür
def bit_say(n):
    sayac = 0
    while n:
        n &= n - 1
        sayac += 1
    return sayac

# 6) Herkes 2 kez, biri 1 kez varsa tekil elemanı bul: hepsini XOR'la
#    (x ^ x = 0 ve x ^ 0 = x olduğundan çiftler birbirini yok eder)
def tekil(dizi):
    sonuc = 0
    for x in dizi:
        sonuc ^= x
    return sonuc

Mantık Kapıları (Logic Gates)

Tek girişli NOT (tersleyici): 0→1, 1→0. İki girişli kapıların tümü tek tabloda:

• NAND = NOT(AND), NOR = NOT(OR), XNOR = NOT(XOR) — “eşitse 1”.
• XOR: girişler farklıysa 1. Parity kontrolünde ve toplayıcı devrelerde kullanılır.
• Half adder (yarım toplayıcı): Sum = A ⊕ B, Carry = A · B — “bit toplama devresi nasıl kurulur?” sorusunun cevabı.

Multiplexer (MUX) ve Demultiplexer (DEMUX) devre çizimi sorulur

MUX (çoklayıcı): Birden fazla giriş arasından birini seçip tek bir çıkışa veren devredir — donanımdaki if/else, ya da elektronik bir anahtar. Hangi girişin seçileceğini select (seçme) hatları belirler.

2:1 MUX iki giriş (I₀, I₁), bir seçme hattı (S) ve bir çıkıştan (Y) oluşur. Sadece üç kapıyla kurulur: bir NOT, iki AND, bir OR.

Devre nasıl okunur? İki AND kapısı birer kapı bekçisi gibi çalışır ve S ile tersi (S̄) birbirinin zıddı olduğu için ikisi asla aynı anda açılamaz:

Kapalı AND’in çıkışı her zaman 0 olduğu ve 0 + X = X olduğu için, OR kapısı açık olan tarafın değerini olduğu gibi geçirir. MUX’un çalışma mantığı tam olarak budur.

Doğruluk tablosu:

(x = don’t care — seçilmeyen girişin değeri çıkışı etkilemez.)

Boyut kuralı ve DEMUX

DEMUX (çözücü / demultiplexer) tam tersidir: tek girişi, seçme hatlarının gösterdiği birden fazla çıkıştan birine yönlendirir. Diğer çıkışlar 0 kalır.

flowchart LR
    subgraph MUX ["MUX — çok giriş, tek çıkış"]
        direction LR
        A1[I0] --> M{{"MUX"}}
        A2[I1] --> M
        A3[I2] --> M
        A4[I3] --> M
        M --> AY[Y]
        AS[S1 S0] -.seçme.-> M
    end
    subgraph DEMUX ["DEMUX — tek giriş, çok çıkış"]
        direction LR
        B1[I] --> D{{"DEMUX"}}
        D --> BY1[Y0]
        D --> BY2[Y1]
        D --> BY3[Y2]
        D --> BY4[Y3]
        BS[S1 S0] -.seçme.-> D
    end

I0 ─┐
    ├─ MUX-A ─┐
I1 ─┘   ↑     │
       S0     ├─ MUX-C ── Y
I2 ─┐         │     ↑
    ├─ MUX-B ─┘    S1
I3 ─┘   ↑
       S0

Boole Cebri ve De Morgan Kuralları

Temel özdeşlikler: A+0=A, A·1=A, A+A'=1, A·A'=0, A+A=A, A·A=A, (A')'=A, A+A·B=A (absorption).

De Morgan çok sık sorulur

(A · B)' = A' + B'     →  "AND'in değili = değillerin OR'u"
(A + B)' = A' · B'     →  "OR'un değili = değillerin AND'i"

Programlamadaki karşılığı — koşul sadeleştirme:

not (a and b)  ==  (not a) or (not b)
not (a or b)   ==  (not a) and (not b)
# örn: not (x > 0 and y > 0)  →  x <= 0 or y <= 0

Doğruluk Tablosu Oluşturma

n değişken → \(2^{n\) satır. Satırlar, 0’dan \(2}n-1\)’e kadar ikilik sayarak yazılır.

Pratik yazma kuralı: en sağ sütun 0101… diye teker, bir solundaki 0011… diye ikişer, sonraki 00001111… diye dörder değişir; en sol sütunun üst yarısı 0, alt yarısı 1 olur.

Örnek: F = (A · B) + C’ için 3 değişkenli tablo (2³ = 8 satır):

Ara sütunlar (A·B, C') eklemek hem hatayı azaltır hem de “adımları göster” beklentisini karşılar.

Minterm gösterimi: F’nin 1 olduğu satır numaraları. Yukarıdaki tablo için F = Σm(0, 2, 4, 6, 7).

Karnaugh Haritası (K-Map)

Boole ifadesini cebirsel uğraş olmadan görsel olarak sadeleştirme yöntemidir. Doğruluk tablosundaki 1’ler haritaya yerleştirilir, komşu 1’ler gruplanır.

Gruplama kuralları:

1. Yalnızca 1’ler gruplanır; grup boyutu 2’nin kuvveti olmalı (1, 2, 4, 8, 16).
2. Gruplar dikdörtgen/kare olmalı; çapraz olmaz.
3. Harita kenarlardan sarmalanır (wrap-around): en sol–en sağ sütunlar ve en üst–en alt satırlar komşudur; dört köşe tek grup olabilir.
4. Mümkün olan en büyük grupları seç; gruplar örtüşebilir; her 1 en az bir grupta olmalı.
5. Her grup için grup içinde değişmeyen değişkenlerin çarpımı yazılır (0 kalan → değilli, 1 kalan → düz). Gruplar OR ile birleştirilir.

Isınma (3 değişken): F(A,B,C) = Σm(1, 3, 5, 7) → 1 olan tüm mintermlerde C = 1, A ve B her değeri alıyor → F = C.

Örnek soru (4 değişken): F(A,B,C,D) = Σm(0, 2, 5, 7, 8, 10, 13, 15) ifadesini K-map ile sadeleştirin.

Minterm numarası = 8A + 4B + 2C + 1D. Harita (satır AB, sütun CD, Gray code sırasıyla):

Bölüm 5 — Otomata Teorisi ve Chomsky Hiyerarşisi

Bilgisayar biliminin teorik temelidir. Soru genelde üç eksende gelir: (1) Chomsky hiyerarşisinin katmanları, (2) her katmana karşılık gelen makine, (3) “şu dil hangi sınıftandır?” örnekleri.

Temel Kavramlar

Gramerin dört bileşeni: G = (V, T, P, S)

• V (Variables / Non-terminal): Büyük harfler — S, A, B (henüz açılacak semboller)
• T (Terminals): Küçük harfler — a, b, 0, 1 (nihai semboller)
• P (Production rules): Üretim kuralları — S → aSb
• S (Start symbol): Başlangıç sembolü

Türetme (derivation) örneği: S → aSb | ab grameriyle aaabbb üretimi: S ⇒ aSb ⇒ aaSbb ⇒ aaabbb ✓

Chomsky Hiyerarşisi (1956) en çok sorulan tablo

Noam Chomsky’nin dilleri üretici güçlerine göre dört seviyeye ayırmasıdır. İç içe geçmiştir: Tip 3 ⊂ Tip 2 ⊂ Tip 1 ⊂ Tip 0. Yani her düzenli dil aynı zamanda bağlamdan bağımsızdır; tersi doğru değildir.

flowchart TD
    A["Tip 0 — Recursively Enumerable<br/>Turing Machine"] --> B["Tip 1 — Context-Sensitive<br/>Linear Bounded Automaton"]
    B --> C["Tip 2 — Context-Free<br/>Pushdown Automaton"]
    C --> D["Tip 3 — Regular<br/>Finite Automaton"]

İçteki her küme dıştakinin alt kümesidir: Tip 3 en kısıtlı, Tip 0 en güçlü.

Kural biçimleri (α → β)

“Bu dil hangi tiptendir?”

Sonlu Otomatlar (Finite Automata) — Tip 3

M = (Q, Σ, δ, q₀, F) beş bileşenden oluşur:

• Q: Durumlar kümesi
• Σ: Giriş alfabesi
• δ: Geçiş fonksiyonu (transition function)
• q₀: Başlangıç durumu
• F: Kabul (final) durumları kümesi

DFA vs NFA çok sık sorulur

Örnek DFA — “çift sayıda a içeren stringler”:

stateDiagram-v2
    direction LR
    [*] --> Cift
    Cift --> Tek : a
    Tek --> Cift : a
    Cift --> Cift : b
    Tek --> Tek : b
    Cift --> [*]

Çift = kabul durumu. abba → Çift→Tek→Tek→Tek→Çift = kabul. aab → Çift→Tek→Çift→Çift = kabul. ab → Tek = ret.

Regular Expression ↔ Regular Language: Düzenli ifadeler (regex) ile sonlu otomatlar denk güçtedir (Kleene Teoremi). a*b+, (a|b)*abb gibi ifadeler birer DFA’ya çevrilebilir.

Pushdown Automaton (PDA) — Tip 2

Sonlu otomat + bir stack. aⁿbⁿ için mantık:

1. Her a gördüğünde stack’e bir sembol push et.
2. Her b gördüğünde stack’ten bir sembol pop et.
3. String bitince stack boşsa kabul, değilse ret.

DPDA vs NPDA: Sonlu otomatların aksine burada NPDA, DPDA’dan güçlüdür. Örneğin tüm palindromlar dili NPDA ile tanınır, DPDA ile tanınmaz.

Pratikteki karşılığı: Programlama dillerinin sözdizimi (syntax) context-free’dir; derleyicilerdeki parser aşaması bir PDA’dır. Ama “değişken kullanılmadan önce tanımlanmış mı” gibi kurallar context-sensitive’dir; bu yüzden derleyiciler ayrı bir semantik analiz aşaması kullanır.

Turing Makinesi (TM) — Tip 0

Sonsuz bir bant üzerinde okuma/yazma yapabilen, başlığı sağa-sola hareket ettirebilen soyut makinedir. Hesaplanabilirliğin sınırını tanımlar.

• Church-Turing Tezi: “Algoritmayla hesaplanabilen her şey bir Turing makinesiyle hesaplanabilir.” Modern bilgisayarlar (sonsuz bellek varsayımıyla) Turing-complete’tir.
• Decidable (Karar verilebilir): TM her girdide durur ve evet/hayır der → Recursive diller.
• Recursively Enumerable: TM “evet” olan girdilerde durur, “hayır” olanlarda sonsuza kadar çalışabilir.
• Halting Problem (Durma Problemi): “Verilen bir programın belirli bir girdide durup durmayacağını” belirleyen genel bir algoritma yoktur. Turing tarafından 1936’da ispatlanmıştır — bilgisayar biliminin en temel imkânsızlık sonucudur.

Derleyici ile İlişkisi

Bölüm 6 — Programlama Paradigmaları ve Tasarım

Nesne Yönelimli Programlama (OOP)

Programı, veri ve o veri üzerinde işlem yapan metodları içeren nesneler etrafında organize eder. Dört temel prensip:

• Encapsulation (Kapsülleme): Veri ve metodları tek birimde (sınıf) birleştirip veriyi dış müdahaleden korumak.
• Inheritance (Kalıtım): Bir sınıfın özellik ve metodlarını başka sınıfa miras bırakması; kod tekrarını önler.
• Polymorphism (Çok Biçimlilik): Farklı nesnelerin aynı metod çağrısına farklı şekillerde cevap verebilmesi.
• Abstraction (Soyutlama): İç detayları gizleyip yalnızca gerekli özellikleri göstermek.

SOLID Prensipleri

Clean Code Prensipleri

• DRY — Don’t Repeat Yourself: Kod tekrarından kaçın.
• KISS — Keep It Simple, Stupid: Basit tut.
• YAGNI — You Aren’t Gonna Need It: İhtiyaç olmayan özelliği önceden yazma.
• Separation of Concerns: Farklı sorumlulukları farklı birimlere ayır.

Dependency Injection (Bağımlılık Enjeksiyonu)

Sınıfın ihtiyaç duyduğu bağımlılıkları kendi içinde oluşturmak yerine dışarıdan almasıdır.

- UserService → new MySQLDatabase()      // sıkı bağlı, test edilemez
+ UserService → Database (interface)     // dışarıdan verilir, mock'lanabilir

Böylece implementasyon değiştirilebilir ve test (mock) kolaylaşır.

Coupling ve Cohesion

• Coupling (Bağlılık): Modüllerin birbirine ne kadar bağımlı olduğu. Düşük olmalı.
• Cohesion (Uyum): Bir modül içindeki sorumlulukların ne kadar ilişkili olduğu. Yüksek olmalı.

İdeal: High Cohesion + Low Coupling.

Fonksiyonel Programlama

Programlamayı matematiksel fonksiyonların değerlendirilmesi olarak görür. Durum (state) ve değişen veriden (mutable data) kaçınır.

Pure function: Aynı girdi için her zaman aynı çıktıyı üreten, yan etkisiz fonksiyon. Kodu tahmin edilebilir ve test edilebilir kılar.

Interface vs Abstract Class sık sorulur

Composition vs Inheritance

• Inheritance: “is-a” ilişkisi (Kedi bir Hayvandır). Sıkı bağlılık yaratabilir.
• Composition: “has-a” ilişkisi (Araba bir Motora sahiptir). Daha esnektir.

Genel kabul: “composition over inheritance” — kalıtım zincirleri büyüdükçe kırılganlaşır.

Tasarım Desenleri (Design Patterns)

MVC (Model-View-Controller)

• Model: Veri ve iş mantığı.
• View: Kullanıcı arayüzü.
• Controller: İstekleri alıp Model ile View arasında koordinasyonu sağlar.

Bölüm 7 — Veritabanı ve SQL

SQL Komut Türleri

Temel Sorgular

-- Filtreleme
SELECT * FROM users WHERE age > 18;

-- Sıralama ve limit
SELECT name, salary FROM employees ORDER BY salary DESC LIMIT 5;

-- Gruplama: GROUP BY gruplar, HAVING grupları filtreler
SELECT department, COUNT(*)
FROM employees
GROUP BY department
HAVING COUNT(*) > 5;

DELETE vs TRUNCATE vs DROP sık sorulur

JOIN Türleri

• INNER JOIN: Her iki tabloda da eşleşen kayıtları getirir.
• LEFT JOIN: Sol tablonun tüm kayıtları + sağdan eşleşenler (eşleşmeyen → NULL).
• RIGHT JOIN: Sağ tablonun tüm kayıtları + soldan eşleşenler.
• FULL OUTER JOIN: Her iki tablonun tüm kayıtları; eşleşmeyen taraflar NULL.

SELECT o.id, c.name
FROM orders o
INNER JOIN customers c ON o.customer_id = c.id;

Primary Key ve Foreign Key

• Primary Key: Her satırı benzersiz tanımlar; NULL olamaz, tekrar edemez.
• Foreign Key: Başka tablonun primary key’ine referans verir; referans bütünlüğünü (referential integrity) sağlar.

Index

Sorguları hızlandıran yapıdır — kitabın arkasındaki dizin gibi. Ancak: ek disk alanı kullanır ve INSERT/UPDATE/DELETE maliyetini artırır, çünkü index de güncellenmek zorundadır.

Normalizasyon sık sorulur

Veri tekrarını (redundancy) azaltıp bütünlüğü artırmak için tabloların düzenlenmesidir. Tekrar; güncelleme, ekleme ve silme anomalilerine yol açar — normalizasyon bunları önler.

View, Stored Procedure, Trigger

• View: Sorgu sonucunu sanal tablo gibi sunar; veri saklamaz; güvenlik ve basitlik sağlar.
• Stored Procedure: Veritabanında saklanan, önceden derlenmiş SQL bloğu; performans ve güvenlik avantajı.
• Trigger: INSERT/UPDATE/DELETE gerçekleştiğinde otomatik çalışan kod bloğu.

SQL vs NoSQL çok sık sorulur

Büyük Verinin 5 V Kuralı sık sorulur

Big Data’yı tanımlayan beş boyuttur ve aslında “NoSQL neden ortaya çıktı?” sorusunun da cevabıdır: ilişkisel veritabanı bu beş boyutun ilk üçünde zorlanmaya başlayınca yeni modeller doğmuştur.

ACID ve BASE

CAP Teoremi

Dağıtık bir sistem aynı anda şu üç garantiden en fazla ikisini sağlayabilir:

• Consistency (Tutarlılık): Tüm node’lar aynı anda aynı veriyi görür.
• Availability (Erişilebilirlik): Her isteğe yanıt alınır.
• Partition Tolerance (Bölünme Toleransı): Ağ kesintilerine rağmen sistem çalışmaya devam eder.

Vektör Veritabanı (Vector Database)

Metin, resim, ses gibi verileri matematiksel vektörler (embedding) olarak depolayan ve vektörler arasında anlamsal benzerlik araması yapmak için optimize edilmiş veritabanıdır. Benzer görsel bulma, anlamsal metin arama ve RAG sistemlerinde kullanılır.

Bölüm 8 — İşletim Sistemleri

Process ve Thread

• Process: Çalışan bir programın bağımsız yürütme ortamıdır; kendi bellek/adres alanı vardır.
• Thread: Process içinde çalışan en küçük yürütme birimidir; bir process birden fazla thread içerebilir.

Concurrency vs Parallelism

• Concurrency (Eşzamanlılık): Birden fazla işin ilerlemesinin yönetilmesi — tek çekirdekte sırayla dönüşümlü de olabilir.
• Parallelism (Paralellik): İşlerin gerçekten aynı anda farklı CPU çekirdeklerinde çalışması.

Deadlock (Kilitlenme)

İki veya daha fazla process’in, birbirinin tuttuğu kaynağı beklemesi ve hiçbirinin ilerleyememesidir.

Dört klasik koşul — hepsi aynı anda sağlanmalı:

1. Mutual Exclusion: Kaynak aynı anda tek process tarafından kullanılabilir.
2. Hold and Wait: Process kaynak tutarken başka kaynak bekler.
3. No Preemption: Kaynak zorla geri alınamaz.
4. Circular Wait: Process’ler döngüsel olarak birbirini bekler.

flowchart LR
    P1[Process 1] -- tutuyor --> R1[(Kaynak A)]
    P2[Process 2] -- tutuyor --> R2[(Kaynak B)]
    P1 -- bekliyor --> R2
    P2 -- bekliyor --> R1

Race Condition

Birden fazla thread’in ortak veriye aynı anda erişmesi ve sonucun işlem sırasına bağlı olarak değişmesi durumudur. Çözümler: Mutex, Lock, Semaphore, atomic operations.

Mutex vs Semaphore sık sorulur

CPU Scheduling sık sorulur

Amaç: hazır (ready) kuyruğundaki process’lerden hangisinin CPU’yu alacağına karar vermek. İki tür vardır: Non-preemptive (process CPU’yu kendi bırakana kadar çalışır) ve Preemptive (OS, çalışan process’i kesip CPU’yu elinden alabilir).

Hesap örneği — hepsi t=0’da geliyor: P1 = 24 ms, P2 = 3 ms, P3 = 3 ms burst.

FCFS (geliş sırası P1,P2,P3):  |   P1 (0-24)  | P2 (24-27) | P3 (27-30) |
  Bekleme: P1=0, P2=24, P3=27  → ortalama (0+24+27)/3 = 17 ms

SJF (kısa önce: P2,P3,P1):     | P2 (0-3) | P3 (3-6) |   P1 (6-30)   |
  Bekleme: P2=0, P3=3, P1=6    → ortalama (0+3+6)/3 = 3 ms

RR (quantum=4):                | P1 (0-4) | P2 (4-7) | P3 (7-10) | P1 (10-30) |
  Bekleme: P1=6, P2=4, P3=7    → ortalama ≈ 5,7 ms

Aynı işler, yalnızca sıralama değişerek ortalama beklemeyi 17 ms’den 3 ms’ye düşürüyor — SJF’in “optimal” iddiasının somut hâli.

Bellek Yönetimi

• Sanal Bellek (Virtual Memory): RAM yetersiz kaldığında diskin bir bölümünün bellek gibi kullanılması.
• Paging (Sayfalama): Belleğin sabit boyutlu sayfalara bölünerek yönetilmesi.

Bölüm 9 — Ağ (Networking)

OSI Modeli (7 Katman)

Ağ iletişimini katmanlara ayıran teorik referans modeldir (ISO, 1984). Amacı: her katman yalnızca kendi işinden sorumlu olsun, alt katmanın nasıl çalıştığını bilmesin. Böylece bir katman değişse (Wi-Fi → Ethernet) üsttekiler etkilenmez.

* ARP genelde Katman 2–3 arası kabul edilir (IP → MAC çözümlemesi).

Katman 2’nin iki alt katmanı: LLC (Logical Link Control — üst katmanla arayüz) ve MAC (Media Access Control — ortama erişim).

Ezber teknikleri

Yukarıdan aşağı (7→1):  Uygulama, Sunum, Oturum, Taşıma, Ağ, Veri Bağlantı, Fiziksel
İngilizce (7→1):        All People Seem To Need Data Processing
İngilizce (1→7):        Please Do Not Throw Sausage Pizza Away
Türkçe (1→7):           "Farklı Veriler Ağdan Taşınır, Oturum Sunumda Uygulanır."

Encapsulation (Kapsülleme) çok sorulur

Veri her katmanda bir başlık (header) eklenerek aşağı iner; karşı tarafta ters işlem (decapsulation) yapılır.

GÖNDEREN (aşağı iner)                       ALICI (yukarı çıkar)
─────────────────────                       ────────────────────
7-5  [ Data ]                                        [ Data ]
 4   [ TCP Header | Data ]          = Segment    [ TCP H | Data ]
 3   [ IP H | TCP H | Data ]        = Packet   [ IP H | TCP H | Data ]
 2   [ MAC H | IP H | TCP H | Data | CRC ] = Frame      ...
 1   0101110100101110...            = Bit           ...

OSI vs TCP/IP sık sorulur

• OSI: 7 katmanlı, teorik/referans model. Önce model tasarlandı, protokoller sonra düşünüldü. Öğretimde ve sorun tespitinde kullanılır.
• TCP/IP (DoD Modeli): 4 katmanlı, pratik model. Önce protokoller yazıldı, model sonra çıkarıldı. İnternet fiilen bunun üzerine kuruludur.

        OSI (7 Katman)                    TCP/IP (4 Katman)
┌──────────────────────────┐      ┌──────────────────────────┐
│ 7. Application           │      │                          │
│ 6. Presentation          │ ───► │  4. Application          │  HTTP, FTP, DNS, SMTP
│ 5. Session               │      │                          │
├──────────────────────────┤      ├──────────────────────────┤
│ 4. Transport             │ ───► │  3. Transport            │  TCP, UDP
├──────────────────────────┤      ├──────────────────────────┤
│ 3. Network               │ ───► │  2. Internet             │  IP, ICMP, ARP
├──────────────────────────┤      ├──────────────────────────┤
│ 2. Data Link             │ ───► │                          │
│ 1. Physical              │      │  1. Network Access       │  Ethernet, Wi-Fi
└──────────────────────────┘      └──────────────────────────┘

Uçtan uca örnek: tarayıcıya www.site.com yazınca ne olur?

1.  DNS sorgusu → alan adı IP'ye çevrilir           (L7 Application, UDP:53)
2.  TCP 3-way handshake: SYN → SYN-ACK → ACK        (L4 Transport)
3.  TLS handshake, şifreleme anahtarı belirlenir    (L6 Presentation)
4.  HTTP GET isteği oluşturulur                     (L7 Application)
5.  Segmentlere bölünür, port eklenir (443)         (L4 Transport)
6.  IP başlığı eklenir, router yolu belirler        (L3 Network)
7.  MAC başlığı eklenir, switch aynı ağda iletir    (L2 Data Link)
8.  Bitler kablo/Wi-Fi üzerinden gider              (L1 Physical)
9.  Sunucuda ters sırayla (1→7) çözülür, yanıt döner

Bu senaryo, “OSI katmanlarını bir örnekle anlat” sorusunun en iyi cevabıdır.

Ağ Topolojileri

Ağdaki cihazların fiziksel/mantıksal yerleşimini ifade eder.

flowchart LR
    A[PC1] --- HAT
    B[PC2] --- HAT
    C[PC3] --- HAT
    D[PC4] --- HAT
    HAT[====== Ana Kablo / Backbone ======]

flowchart TD
    S((Switch)) --- A[PC1]
    S --- B[PC2]
    S --- C[PC3]
    S --- D[PC4]
    S --- E[PC5]

flowchart LR
    A[PC1] --> B[PC2] --> C[PC3] --> D[PC4] --> A

flowchart TD
    A[PC1] --- B[PC2]
    A --- C[PC3]
    A --- D[PC4]
    B --- C
    B --- D
    C --- D

flowchart TD
    R((Kök Switch)) --- S1((Switch 1))
    R --- S2((Switch 2))
    S1 --- A[PC1]
    S1 --- B[PC2]
    S2 --- C[PC3]
    S2 --- D[PC4]

Hub vs Switch vs Router sık sorulur

MAC vs IP Adresi sık sorulur

ARP (Address Resolution Protocol) sık sorulur

Aynı yerel ağdaki bir cihazın IP adresinden MAC adresini bulur — L3 ile L2 arasındaki köprüdür. Çünkü yerel ağda çerçevelerin (frame) teslimatı MAC ile yapılır.

Alt Ağlar (Subnetting) hesap sorusu

Büyük bir IP ağını daha küçük, yönetilebilir parçalara bölme işlemidir. Faydaları: broadcast trafiğini azaltır, güvenliği artırır (bölümler izole edilir), IP adres yönetimini kolaylaştırır.

• Subnet mask, adresin ağ ve host kısmını ayırır: /24 = 255.255.255.0 → ilk 24 bit ağ, son 8 bit host.
• Host sayısı:

Ağ adresi ve broadcast adresi düşüldüğü için -2 var. /24 → 254 host, /26 → 62 host.

Ağ adresini bulma — IP ile maske AND’lenir:

IP    192.168.1.130 → 11000000.10101000.00000001.10000010
Mask  /26 (255.255.255.192) → 11111111.11111111.11111111.11000000
AND   ─────────────────────────────────────────────────────
Ağ    192.168.1.128 → 11000000.10101000.00000001.10000000

Son oktet: 10000010 AND 11000000 = 10000000 = 128 → ağ adresi 192.168.1.128/26.

“İki IP aynı alt ağda mı?” — Her iki IP maskeyle AND’lenir; ağ adresleri eşitse aynı subnet’tir (doğrudan haberleşirler), değilse aradan router geçmesi gerekir.

192.168.1.130 AND /26 → 192.168.1.128
192.168.1.140 AND /26 → 192.168.1.128  → AYNI alt ağ ✓
192.168.1.200 AND /26 → 192.168.1.192  → FARKLI alt ağ ✗ (router gerekir)

Örnek soru: 192.168.10.0/24 ağı /26 ile alt ağlara bölünürse kaç alt ağ oluşur ve 192.168.10.70 hangisindedir?

TCP vs UDP çok sık sorulur

TCP Bağlantı Kurulumu ve Kapanışı sık sorulur

sequenceDiagram
    participant C as İstemci
    participant S as Sunucu
    Note over C,S: Kurulum — Three-Way Handshake
    C->>S: SYN
    S->>C: SYN-ACK
    C->>S: ACK
    Note over C,S: ... veri alışverişi ...
    Note over C,S: Kapanış — Four-Way Termination
    C->>S: FIN (işim bitti)
    S->>C: ACK
    S->>C: FIN (benim de bitti)
    C->>S: ACK  → TIME_WAIT

• Kurulum neden 3 adım? Her iki taraf da hem “gönderebiliyorum” demeli hem karşı tarafın duyduğunu onaylamalı; ayrıca başlangıç sequence number’ları senkronize edilir.
• Kapanış neden 4 adım? Bağlantı çift yönlüdür; her yön ayrı kapatılır. Bir taraf FIN gönderdikten sonra karşı tarafın hâlâ gönderecek verisi olabilir (half-close) — bu yüzden FIN ve ACK’ler her zaman birleştirilemez.
• TIME_WAIT: Kapanışı başlatan taraf, son ACK’ten sonra bir süre (2×MSL) bekler — geciken paketlerin yeni bir bağlantıya karışmaması ve son ACK kaybolursa tekrar gönderilebilmesi için.

DNS (Domain Name System) sık sorulur

Alan adlarını (www.ornek.com) IP adreslerine çevirir — “internetin telefon rehberi”.

Alan adı hiyerarşisi: kök . → TLD (.com, .tr) → domain (ornek.com) → subdomain (blog.ornek.com).

DNS kayıt türleri:

DHCP

Ağa bağlanan cihazlara otomatik IP ve ağ ayarları (maske, gateway, DNS) atar. 4 adım — DORA:

D iscover  → istemci: "ortalıkta DHCP sunucusu var mı?"  (broadcast)
O ffer     → sunucu:  "şu IP'yi sana verebilirim"
R equest   → istemci: "kabul, o IP'yi istiyorum"
A cknowledge → sunucu: "tamam, kiralandı (lease)"

IPv4 vs IPv6 sık sorulur

NAT, Firewall, VPN

• NAT: Yerel (özel) IP’lerin tek bir genel IP üzerinden internete çıkmasını sağlar.
• Firewall: Trafiği kurallara göre filtreler, yetkisiz erişimi engeller.
• VPN: İnternet üzerinden şifreli, güvenli bir tünel oluşturur.

Bölüm 10 — HTTP, REST ve Web

HTTP Metodları

Idempotent = aynı isteği 10 kez göndermekle 1 kez göndermek arasında sonuç farkı yoktur.

HTTP Durum Kodları

200 OK                      → başarılı
201 Created                 → kaynak oluşturuldu
204 No Content              → başarılı, gövde yok

301 Moved Permanently       → kalıcı yönlendirme
400 Bad Request             → hatalı istek
401 Unauthorized            → kimlik doğrulama gerekli/başarısız
403 Forbidden               → kimlik belli ama yetki yok
404 Not Found               → kaynak bulunamadı
409 Conflict                → çakışma
422 Unprocessable Content   → doğrulama hatası

500 Internal Server Error   → sunucu hatası
502 Bad Gateway             → ara sunucu hatalı yanıt aldı
503 Service Unavailable     → servis kullanılamıyor

REST

Web servislerinin kaynaklar (resources) üzerinden standart HTTP prensipleriyle tasarlandığı mimari yaklaşımdır.

GET    /users       → tüm kullanıcıları listele
GET    /users/15    → 15 numaralı kullanıcıyı getir
POST   /users       → yeni kullanıcı oluştur
PUT    /users/15    → 15'i tamamen güncelle
DELETE /users/15    → 15'i sil

Stateless: Sunucu, istemcinin önceki isteğinin durumunu tutmak zorunda değildir; her istek gerekli tüm bilgiyi taşır. Bu, yatay ölçeklemeyi mümkün kılan özelliktir — herhangi bir sunucu herhangi bir isteği karşılayabilir.

REST vs SOAP

• REST: Hafif, JSON ağırlıklı, HTTP metodlarını kullanır, stateless.
• SOAP: XML tabanlı, katı kurallı bir protokol; daha ağır ama kurumsal güvenlik özellikleri (WS-Security) sunar.

HTTP vs HTTPS

HTTPS = HTTP + SSL/TLS şifrelemesi. Trafik şifrelenir; araya girme (man-in-the-middle) saldırıları engellenir. Portlar: HTTP 80, HTTPS 443.

TLS Handshake sık sorulur

Amaç: birbirini tanımayan iki tarafın, dinlenen bir hat üzerinde ortak bir gizli anahtarda anlaşması ve sunucunun kimliğinin doğrulanması.

HTTP/1.1 vs HTTP/2 vs HTTP/3 sık sorulur

Cookie, Session, JWT

Bölüm 11 — Yazılım Güvenliği

Authentication vs Authorization

Yaygın Saldırılar ve Önlemler

Hashing, Encryption ve Encoding sık sorulur

Üçü de veriyi “okunamaz” hâle getirdiği için sürekli karıştırılıyor. Oysa amaçları tamamen farklı ve aralarındaki tek ayırt edici soru şu: geri döndürülebilir mi, döndürülebiliyorsa neye ihtiyaç var?

Hashing     "sifre123"  → hash    → a8f5f167f44f4964e6c998dee827110c   → ✗ geri dönüş YOK
Encryption  "sifre123"  → encrypt → U2FsdGVkX1+9k2... ──decrypt(🔑)──→ "sifre123"
Encoding    "sifre123"  → encode  → c2lmcmUxMjM=      ──decode()────→ "sifre123"

import base64
base64.b64decode("c2lmcmUxMjM=")   # b'sifre123'

Simetrik vs Asimetrik Şifreleme

Pratikte ikisi birlikte kullanılır: asimetrik ile anahtar paylaşılır, iletişim simetrik ile devam eder.

Bölüm 12 — Yazılım Testi

Test Seviyeleri

• Unit Test: Tek bir fonksiyon/metod/modülün tek başına testi.
• Integration Test: Bileşenlerin birlikte doğru çalışmasının testi.
• System Test: Sistemin bütün olarak testi.
• Acceptance Test (UAT): Kullanıcı/iş gereksinimlerinin karşılandığının, genellikle müşteri tarafından kontrolü.
• Regression Test: Yeni değişikliklerin mevcut çalışan özellikleri bozup bozmadığının kontrolü.

Black Box vs White Box

• Black Box: İç yapı bilinmeden, yalnızca girdi-çıktı davranışına göre test.
• White Box: Kodun iç yapısı (dallanma, döngü, kod kapsamı) bilinerek test.

Test Piramidi

flowchart TD
    E2E["E2E / UI Testleri (az sayıda, yavaş, pahalı)"] --> INT["Integration Testleri (orta)"]
    INT --> UNIT["Unit Testler (çok sayıda, hızlı, ucuz)"]

Çok sayıda unit test, daha az integration, en az E2E test tercih edilir. Sebep basit: bir hata ne kadar aşağıdaki katmanda yakalanırsa bulunması ve düzeltilmesi o kadar ucuzdur.

Verification vs Validation

• Verification: “Ürünü doğru mu yapıyoruz?” → belgelere/tasarıma uygunluk.
• Validation: ”Doğru ürünü mü yapıyoruz?" → gerçek kullanıcı ihtiyacını karşılama.

Bölüm 13 — Git ve Versiyon Kontrolü

Temel Komutlar

git clone <url>        # depoyu indir
git status             # durumu göster
git add <dosya>        # değişikliği stage'e al
git commit -m "..."    # kaydet
git push               # uzak depoya gönder
git pull               # uzak depodan al ve birleştir
git fetch              # uzak değişiklikleri indir (birleştirmez)
git branch             # dalları listele/oluştur
git checkout / switch  # dal değiştir
git merge <dal>        # dalı birleştir
git rebase <dal>       # commit'leri başka dalın üzerine taşı
git stash              # değişiklikleri geçici kaydet

Merge vs Rebase

Pull vs Fetch

• fetch: Uzak değişiklikleri indirir, mevcut dalı değiştirmez. Güvenlidir; önce bakıp sonra karar verirsin.
• pull: Kabaca fetch + merge (veya fetch + rebase) işlemidir.

Conflict (Çakışma)

Aynı dosyanın aynı satırlarının iki dalda farklı değiştirilmesiyle oluşur. Git hangi değişikliğin doğru olduğuna karar veremez; manuel çözülür, sonra commit edilir.

Bölüm 14 — Mimari, Cloud ve Dağıtık Sistemler

Monolith vs Microservices

• Monolith: Uygulama tek deploy edilebilir birimdir. Başlangıçta basittir; büyüdükçe bakım ve ölçekleme zorlaşır.
• Microservices: Sistem, bağımsız geliştirilen/deploy edilen küçük servislerden oluşur; servisler API (REST) veya mesajlaşma ile haberleşir.

Vertical vs Horizontal Scaling

• Vertical (Dikey): Mevcut sunucuyu güçlendirmek (daha fazla CPU/RAM). Basit ama fiziksel bir sınırı vardır.
• Horizontal (Yatay): Daha fazla sunucu eklemek. Teorik olarak sınırsız ölçeklenir; load balancer gerektirir ve uygulamanın stateless olmasını ister.

Load Balancer

Gelen istekleri birden fazla sunucuya dağıtır; hiçbir sunucu aşırı yüklenmez, erişilebilirlik artar. Ayrıca sağlıksız sunucuları devre dışı bırakarak (health check) kesintiyi gizler.

Cache

Sık kullanılan verileri hızlı erişilen bir katmanda tutarak veritabanı/ağ yükünü azaltır (Redis, Memcached).

flowchart TD
    C[Client] --> A[API]
    A --> K{Cache'te var mı?}
    K -- Evet --> H[Hızlı cevap döner]
    K -- Hayır --> D[(Database)]
    D --> Y[Cevap + cache'e yazılır]

Message Queue

Servislerin asenkron haberleşmesini sağlar (RabbitMQ, Kafka).

flowchart LR
    A[Service A] --> Q[[Message Queue]] --> B[Service B]

Avantajları: asenkron işlem, servislerin birbirinden ayrılması (decoupling), trafik patlamalarının yönetilmesi (buffer), retry mekanizmaları.

CDN (Content Delivery Network)

Statik içeriği (görsel, video, JS/CSS) kullanıcıya coğrafi olarak yakın sunuculardan servis ederek gecikmeyi azaltır.

Docker ve Container

• Container vs VM: VM kendi işletim sistemi çekirdeğini çalıştırır; container host kernel’ını paylaşır → çok daha hafiftir ve saniyeler içinde başlar. “Benim makinemde çalışıyordu” sorununu çözer.
• Bilinmesi gereken kavramlar: Image (şablon), Container (çalışan örnek), Dockerfile (image tarifi), Volume (kalıcı veri), Network, Registry (image deposu, örn. Docker Hub).
• Kubernetes: Çok sayıda container’ın dağıtım, ölçekleme ve yönetimini otomatikleştiren orkestrasyon platformudur.

CI/CD

• CI (Continuous Integration): Kodun sık sık ana dala birleştirilmesi; her birleştirmede otomatik derleme + test.
• CD (Continuous Delivery/Deployment): Testleri geçen kodun otomatik olarak canlıya (veya canlıya hazır hâle) taşınması.
• Araçlar: Jenkins, GitLab CI, GitHub Actions.

Bölüm 15 — Yapay Zeka ve Makine Öğrenmesi

AI vs ML vs DL

• AI (Yapay Zeka): En geniş kavram; makinelerin insan benzeri zekâ (öğrenme, problem çözme) göstermesini amaçlar.
• ML (Makine Öğrenmesi): AI’ın alt dalı; makinelerin açıkça programlanmadan verilerden öğrenmesi.
• DL (Derin Öğrenme): ML’in alt dalı; çok katmanlı yapay sinir ağları kullanır. Büyük veri ve karmaşık desenlerde (görüntü, doğal dil) çok başarılıdır.

flowchart TD
    AI[Yapay Zeka - AI] --> ML[Makine Öğrenmesi - ML] --> DL[Derin Öğrenme - DL]

Gözetimli ve Gözetimsiz Öğrenme

• Supervised (Gözetimli): Etiketli verilerle eğitim; model girdi-çıktı ilişkisini öğrenir.
  • Classification (Sınıflandırma): Çıktı kategoriktir. Örn: spam / spam değil.
  • Regression (Regresyon): Çıktı sayısaldır. Örn: evin metrekaresinden fiyat tahmini.
• Unsupervised (Gözetimsiz): Etiketsiz veride gizli yapı/desen/grup arar. En yaygın örnek: kümeleme (clustering) — müşterileri davranışa göre gruplamak.

Görüntü İşleme Görevleri: Classification, Detection, Segmentation

Üçü de gözetimli öğrenmedir ve sürekli karıştırılır. Ayrım, modelin ne kadar ayrıntı ürettiğidir:

Classification   →  [kedi]                       (konum yok)
Detection        →  [kedi @ (x, y, w, h)]        (kutu var)
Segmentation     →  [kedi = şu piksel kümesi]    (kenarı tam)

Detection modelleri ikiye ayrılır (sık sorulur):

• Two-stage (Faster R-CNN): Önce aday bölge üretir, sonra sınıflandırır. Daha hassas, daha yavaş.
• One-stage (YOLO, SSD): Tespiti tek geçişte yapar. Gerçek zamanlı uygulamaların tercihi.

Metrikler de farklıdır: sınıflandırmada accuracy/precision/recall/F1 kullanılırken, tespitte IoU (kutuların örtüşme oranı) ve mAP (mean Average Precision) kullanılır.

Overfitting ve Underfitting

Bias vs Variance

Yüksek bias     → model fazla basit  → underfitting  (iyi öğrenemedi)
Yüksek variance → veriye fazla duyarlı → overfitting (ezberledi)

Amaç ikisi arasında denge kurmaktır: bias-variance tradeoff.

Train / Validation / Test Ayrımı

Training    → modeli eğitmek
Validation  → hiperparametre / model seçmek
Test        → final performansı ölçmek (eğitimde ASLA kullanılmaz)

Confusion Matrix ve Metrikler

                    Tahmin
                 Pozitif  Negatif
Gerçek Pozitif     TP       FN
Gerçek Negatif     FP       TN

• Precision — “Pozitif dediklerimin kaçı gerçekten pozitif?”
• Recall — “Gerçek pozitiflerin kaçını yakaladım?”
• F1 Score — Precision ve Recall’un harmonik ortalaması.

Embedding

Metin, kelime, resim gibi verilerin anlamını/özelliklerini temsil eden sayısal vektöre dönüştürülmesidir. Anlamca benzer veriler vektör uzayında birbirine yakın konumlanır. Vektör veritabanları bu vektörler üzerinde benzerlik araması yapar.

LLM, Token ve RAG

• LLM (Large Language Model): Büyük miktarda metinle eğitilmiş; metin üretme/anlama görevlerini yapan model.
• Token: LLM’in metni işlediği temel parça; her zaman tam bir kelime olmak zorunda değildir.
• RAG (Retrieval-Augmented Generation): LLM’in cevap üretmeden önce harici bir bilgi kaynağından ilgili bilgileri getirmesi yaklaşımı.

flowchart TD
    A[Doküman] --> B[Chunking - parçalama]
    B --> C[Embedding]
    C --> D[(Vector Database)]
    E[Kullanıcı Sorusu] --> F[Similarity Search]
    D --> F
    F --> G[İlgili Dokümanlar]
    G --> H[LLM]
    E --> H
    H --> I[Cevap]

RAG neden kullanılır? Güncel/özel verilere erişim, kuruma özel dokümanlarla çalışma, halüsinasyonları azaltma ve modeli yeniden eğitmeden bilgi kaynağını değiştirebilme.

Bölüm 16 — Programlama Temelleri

Derleyici vs Yorumlayıcı

• Compiler: Kodun tamamını önceden makine koduna çevirir (C, C++, Go); çalışması hızlıdır.
• Interpreter: Kodu satır satır çalıştırır (Python, JavaScript); esnektir ama genellikle daha yavaştır.
• Ara model: Java → bytecode → JVM üzerinde çalışır (JIT ile sıcak yollar makine koduna derlenir).

Compile-time vs Runtime

• Compile-time: Derleme sırasında yakalanan hatalar — sözdizimi, tip hataları (statik dillerde).
• Runtime: Program çalışırken oluşan hatalar — sıfıra bölme, null referans, dosya bulunamadı.

Pass by Value vs Pass by Reference

• Value: Fonksiyona kopya gönderilir; içerideki değişiklik orijinali etkilemez.
• Reference: Adres gönderilir; değişiklik orijinali de etkiler.

Garbage Collection

Kullanılmayan bellek alanlarının otomatik tespit edilip serbest bırakılmasıdır (Java, C#, Python, Go). C/C++‘ta bellek yönetimi geliştiricinin sorumluluğundadır.

Synchronous vs Asynchronous

• Senkron: İşlem bitene kadar beklenir; sıradaki işlem bloklanır.
• Asenkron: İşlem başlatılır, sonucu beklemeden devam edilir; sonuç geldiğinde (callback/promise/async-await) işlenir. I/O yoğun işlerde verimlidir.

Bölüm 17 — Python Kod Örnekleri

Sınavda elle yazdırılabilecek klasikler. Hepsini ezberlemek değil, mantığını anlatabilmek hedef.

Bubble Sort

def bubble_sort(liste):
    n = len(liste)
    for i in range(n - 1):
        for j in range(n - 1 - i):
            if liste[j] > liste[j + 1]:
                liste[j], liste[j + 1] = liste[j + 1], liste[j]  # yer değiştir
    return liste

print(bubble_sort([5, 2, 9, 1, 7]))   # [1, 2, 5, 7, 9]

• Time: O(n²) — iç içe iki döngü. Space: O(1) (yerinde sıralama).
• Optimizasyon: Bir turda hiç takas olmadıysa liste sıralıdır, erken çıkılabilir → en iyi durum O(n).

Asal sayıları listeleme

def asal_mi(sayi):
    if sayi < 2:
        return False
    for i in range(2, int(sayi ** 0.5) + 1):   # kareköke kadar bakmak yeterli
        if sayi % i == 0:
            return False
    return True

n = int(input("Bir sayı girin: "))
for sayi in range(2, n + 1):
    if asal_mi(sayi):
        print(sayi, end=" ")

Örnek: girdi 20 → çıktı 2 3 5 7 11 13 17 19

Fibonacci

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

n = int(input("Kaç Fibonacci sayısı? "))
for i in range(n):
    print(fibonacci(i), end=" ")   # 0 1 1 2 3 5 8 13 ...

def fib(n):
    if n <= 1:          # base case
        return n
    return fib(n - 1) + fib(n - 2)

from functools import lru_cache

@lru_cache(maxsize=None)
def fib_hizli(n):
    if n <= 1:
        return n
    return fib_hizli(n - 1) + fib_hizli(n - 2)

Girilen sayıları toplama

adet = int(input("Kaç sayı gireceksiniz? "))
toplam = 0
for i in range(adet):
    sayi = float(input(f"{i + 1}. sayı: "))
    toplam += sayi
print("Toplam:", toplam)

toplam = 0
while True:
    girdi = input("Sayı girin (bitirmek için Enter): ")
    if girdi == "":
        break
    toplam += float(girdi)
print("Toplam:", toplam)

sayilar = input("Sayıları boşlukla girin: ").split()   # "3 5 8" → ['3','5','8']
print("Toplam:", sum(int(s) for s in sayilar))

Metni ters çevirme ve palindrom

metin = input("Bir metin girin: ")

# Yöntem 1: Dilimleme (Pythonic)
print(metin[::-1])

# Yöntem 2: Döngü ile (mantığını göstermek için)
ters = ""
for karakter in metin:
    ters = karakter + ters    # her karakteri başa ekle
print(ters)

# Yöntem 3: reversed() ile
print("".join(reversed(metin)))

# Palindrom kontrolü — ters çevirmenin doğrudan devamı
metin = input("Metin girin: ").lower().replace(" ", "")
if metin == metin[::-1]:
    print("Palindrom")      # örn: "kayak", "ey edip adanada pide ye"
else:
    print("Palindrom değil")

Faktöriyel

# İteratif
def faktoriyel(n):
    sonuc = 1
    for i in range(2, n + 1):
        sonuc *= i
    return sonuc

# Recursive
def faktoriyel_r(n):
    if n <= 1:            # base case
        return 1
    return n * faktoriyel_r(n - 1)

print(faktoriyel(5))      # 120

Kısa klasikler

# --- Listede en büyük / en küçük ---
sayilar = [4, 12, 7, 1, 9]
print(max(sayilar), min(sayilar))          # hazır fonksiyonla

en_buyuk = sayilar[0]                      # döngüyle (mantık sorulursa)
for s in sayilar:
    if s > en_buyuk:
        en_buyuk = s
print(en_buyuk)                            # O(n)

# --- Tek / çift ---
sayi = int(input("Sayı girin: "))
print("Çift" if sayi % 2 == 0 else "Tek")

# --- Rakamların toplamı ---
sayi = int(input("Sayı girin: "))
toplam = 0
while sayi > 0:
    toplam += sayi % 10   # son rakamı al
    sayi //= 10           # son rakamı at
print("Rakamlar toplamı:", toplam)         # 1234 → 10

# --- FizzBuzz ---
for i in range(1, 101):
    if i % 15 == 0:
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)