Scala for Backend Engineering & Functional Programming · Ders

Özyinelemeli Düşünme

Temel durumlar ve özyinelemeli adımlar.

Özyinelemeli Düşünme, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Scala for Backend Engineering & Functional Programming öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

Özyineleme Ne Anlama Gelir

Özyineleme, bir işlevin aynı problemin daha küçük bir sürümünü çözmek için kendisini çağırmasıdır.

Scala'da özyineleme, değiştirilebilir değişkenler olmadan döngüleri ifade etmenizi sağladığı için işlevsel programlamaya doğal olarak uygundur.

Her özyinelemeli işlevin iki şeye ihtiyacı vardır: durmanın bir yolu ve problemi küçültmenin bir yolu.

Önce Temel Durum

Temel durum, işlevin başka bir özyinelemeye gerek kalmadan doğrudan yanıtlayabildiği en basit girdidir.

Temel durum olmazsa işlev kendisini sonsuza kadar çağırır ve yığın taşmasıyla çöker.

Özyinelemeli adımı tasarlamadan önce her zaman temel durumu tasarlayın.

def countdown(n: Int): Unit =
  if (n < 0) ()           // base case: stop
  else {
    println(n)
    countdown(n - 1)      // recursive step
  }

İlk Özyinelemeli İşlev

1 ile n arasındaki sayıları toplayan eksiksiz bir programı burada görebilirsiniz.

Temel durum 0 döndürür; özyinelemeli durum ise n ile kendisinden küçük tüm sayıların toplamını toplar.

def sum(n: Int): Int =
  if (n == 0) 0
  else n + sum(n - 1)

@main def run(): Unit =
  println(sum(5))   // 15

Çağrıları İzleme

Özyinelemeyi anlamak için çağrıları elle açın.

sum(3), 3 + sum(2) olur; bu da 3 + 2 + sum(1), ardından 3 + 2 + 1 + sum(0) hâline gelir.

Zincir ancak sum(0) 0 döndürdüğünde tek bir değere, yani 6'ya çöker.

// sum(3)
// = 3 + sum(2)
// = 3 + (2 + sum(1))
// = 3 + (2 + (1 + sum(0)))
// = 3 + (2 + (1 + 0))
// = 6

Listelerde Özyineleme

Listeler doğaları gereği özyinelemelidir: bir liste ya boştur (Nil) ya da daha küçük bir kuyruk tarafından izlenen bir baştan oluşur.

Bu yapı doğrudan özyinelemeli işlevlere uyarlanır. Boş liste temel durumdur; baş ile kuyruk üzerinde özyinelemenin birleştirilmesi özyinelemeli adımdır.

def length[A](xs: List[A]): Int = xs match {
  case Nil     => 0
  case _ :: t  => 1 + length(t)
}

Kuyrukla Örüntü Eşleme

:: örüntüsü, boş olmayan bir listeyi baş ve kuyruk olarak ayırır.

Her özyinelemeli çağrı kesinlikle daha kısa bir liste üzerinde çalışır ve böylece Nil'e doğru ilerleme garanti edilir.

Scala'da bir listede özyinelemeli olarak ilerlemenin standart yolu budur.

def sumList(xs: List[Int]): Int = xs match {
  case Nil    => 0
  case h :: t => h + sumList(t)
}

@main def run(): Unit =
  println(sumList(List(1, 2, 3, 4)))  // 10

İki Özyinelemeli Çağrı

Bazı problemler birden fazla özyinelemeli çağrıya ayrılır.

Klasik örnek, her değerin kendisinden önceki iki değere bağlı olduğu Fibonacci'dir.

Bu basit yaklaşım yavaştır; çünkü aynı değerleri birçok kez yeniden hesaplar.

def fib(n: Int): Int =
  if (n < 2) n
  else fib(n - 1) + fib(n - 2)

@main def run(): Unit =
  println(fib(7))   // 13

Yığın Maliyeti

Her özyinelemeli çağrı, iç çağrının dönmesini beklemek zorunda olan çağrı yığınına bir çerçeve ekler.

Çok derin özyinelemede bu durum yığını tüketebilir ve bir StackOverflowError fırlatabilir.

Yalnızca boyutu değil, derinliği de saymak bu riski öngörmenize yardımcı olur.

// This would overflow the stack for large n:
// def deep(n: Int): Int =
//   if (n == 0) 0 else 1 + deep(n - 1)
// deep(1000000)  // StackOverflowError

Temel Duruma Doğru Küçülme

Özyinelemenin temel değişmezi, her çağrının temel duruma yaklaşması gerektiğidir.

Bağımsız değişken küçülmüyorsa veya durma koşuluna hiç ulaşmıyorsa özyineleme sona ermez.

Herhangi bir şeyi çalıştırmadan önce bunu kontrol edin.

def reverse[A](xs: List[A]): List[A] = xs match {
  case Nil    => Nil
  case h :: t => reverse(t) :+ h   // t is smaller than xs
}

Özyineleme ve Döngüler

Buyrukçu kod, değiştirilebilir sayaçlarla while döngüleri kullanır; işlevsel kod ise değişmez değerlerle özyineleme kullanır.

İkisi de aynı hesaplamaları ifade edebilir; ancak özyineleme verinin yapısını daha doğrudan açıklar.

Scala'da çoğu zaman ham döngüler yerine özyinelemeyi veya üst düzey işlevleri tercih edersiniz.

// Imperative
var total = 0
for (i <- 1 to 5) total += i

// Recursive
def sum(n: Int): Int = if (n == 0) 0 else n + sum(n - 1)

Özyinelemeli Bir Çözüm Tasarlama

Güvenilir bir yöntem şöyledir: temel durumu belirleyin, özyinelemeli çağrının daha küçük girdi üzerinde zaten çalıştığını varsayın ve ardından başı bu sonuçla birleştirin.

Bu güven adımı, özyinelemeli düşüncenin özüdür. Küçük çağrıya güvenir ve yalnızca bir adımı ele alırsınız.

def maxOf(xs: List[Int]): Int = xs match {
  case h :: Nil => h
  case h :: t   => math.max(h, maxOf(t))
}

@main def run(): Unit =
  println(maxOf(List(3, 9, 2, 7)))  // 9

Hızlı Kontrol

Özyinelemeli yapıyı anlayışınızı test edin.

Özet

Özyineleme, bir problemi kendisinin daha küçük bir örneğine indirgeyerek çözer.

Her özyinelemeli işlevin durmak için bir temel duruma ve girdiyi bu temele doğru küçülten bir özyinelemeli adıma ihtiyacı vardır.

Nil ve baş-kuyruk yapılarıyla listeler, özyinelemeli düşünceyi uygulamak için ideal bir alandır. Çok büyük girdilerde yığın derinliğine dikkat edin.

Sıkça Sorulan Sorular

“Özyinelemeli Düşünme” dersi ücretsiz mi?

Evet — “Özyinelemeli Düşünme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Scala for Backend Engineering & Functional Programming kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

“Özyinelemeli Düşünme” dersinde ne öğreneceğim?

Temel durumlar ve özyinelemeli adımlar. Scala for Backend Engineering & Functional Programming ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Scala for Backend Engineering & Functional Programming öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Scala for Backend Engineering & Functional Programming, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Özyinelemeli Düşünme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Scala for Backend Engineering & Functional Programming dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Scala for Backend Engineering & Functional Programming dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Scala for Backend Engineering & Functional Programming Sayfasına Dön