Go Academy · Ders

Genel Veri Yapıları

Genel bir Stack ve Set oluşturma

Genel Veri Yapıları, CoddyKit'te ücretsiz bir Go Academy dersidir. Bu, 4 dersinin 3. 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, Go Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Go Academy kursu toplamda 4 dersten oluşur.

Genel veri yapıları neden kullanılmalı?

Genel türlerden önce Go geliştiricileri, tür güvenliğini kaybettikleri interface{} dilimlerini kullanıyor veya her tür için kod üretiyordu. Genel türler, tür güvenli ve yeniden kullanılabilir kapsayıcılar oluşturmayı sağlar.

Jenerik yığın

Jenerik bir tür kullanan, tür güvenli bir yığın:

type Stack[T any] struct{ items []T }
func (s *Stack[T]) Push(v T)        { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() (T, bool)  {
    if len(s.items)==0 { var z T; return z, false }
    n := len(s.items)-1; v := s.items[n]; s.items = s.items[:n]; return v, true
}
func (s *Stack[T]) Len() int { return len(s.items) }

Jenerik kuyruk

Bir dilim tarafından desteklenen FIFO kuyruğu:

type Queue[T any] struct{ items []T }
func (q *Queue[T]) Enqueue(v T)     { q.items = append(q.items, v) }
func (q *Queue[T]) Dequeue() (T, bool) {
    if len(q.items)==0 { var z T; return z, false }
    v := q.items[0]; q.items = q.items[1:]; return v, true
}

Jenerik küme

Bir harita tarafından desteklenen küme — anahtar türü karşılaştırılabilir olmalıdır:

type Set[T comparable] struct{ m map[T]struct{} }
func NewSet[T comparable]() *Set[T] { return &Set[T]{m: make(map[T]struct{})} }
func (s *Set[T]) Add(v T)          { s.m[v] = struct{}{} }
func (s *Set[T]) Has(v T) bool     { _, ok := s.m[v]; return ok }
func (s *Set[T]) Delete(v T)       { delete(s.m, v) }

Jenerik Map yardımcısı

Dilimler üzerinde tür güvenli işlevsel bir Map:

func Map[T, U any](s []T, f func(T) U) []U {
    out := make([]U, len(s))
    for i, v := range s { out[i] = f(v) }
    return out
}

Jenerik Filter

Yalnızca bir koşulu sağlayan öğeleri içeren yeni bir dilim döndürün:

func Filter[T any](s []T, predicate func(T) bool) []T {
    var out []T
    for _, v := range s {
        if predicate(v) { out = append(out, v) }
    }
    return out
}

Jenerik Reduce

Bir dilimi tek bir değere katlayın:

func Reduce[T, U any](s []T, init U, f func(U, T) U) U {
    acc := init
    for _, v := range s { acc = f(acc, v) }
    return acc
}

OrderedMap

Eklenme sırasını koruyan sıralı bir harita — anahtar sırasının sabit kalması gereken JSON serileştirmesinde kullanışlıdır:

type OrderedMap[K comparable, V any] struct {
    keys []K
    vals map[K]V
}

Jenerik bağlı liste

Tür güvenli öğelere sahip çift bağlı bir liste:

type Node[T any] struct{ Val T; Next, Prev *Node[T] }
type List[T any] struct{ head, tail *Node[T]; len int }

Sınırlamalar

Jenerik türler, T üzerinde tür değiştirme kullanamaz. Jenerik türlerin yöntemleri yeni tür parametreleri tanımlayamaz. Belirli bir T için jenerik bir türü özelleştiremezsiniz (şablon özelleştirmesi yoktur).

Performans

Go'da jenerik örnekleme, "GC şekilleri" aracılığıyla yapılır — aynı bellek düzenine sahip türler tek bir uygulamayı paylaşır. Bu yaklaşım, somut uygulamalara yakın performansı korurken kod şişmesini önler.

Jenerik türler ne zaman kullanılmamalı?

Bir arayüzün yeterli olduğu basit durumlarda veya yalnızca bir ya da iki somut türünüz olduğunda jenerik türlerden kaçının — ek karmaşıklık sağladığı faydadan ağır basar.

Kısa kontrol

Jenerik bir Set, tür parametresinde neden comparable kısıtını gerektirir?

Özet: Jenerik veri yapıları

Temel noktalar:

Yığın, kuyruk ve Set — jenerik türlerle tür güvenlidir
İşlevsel yardımcılar: []T üzerinde Map, Filter ve Reduce
Harita destekli kümeler için Set[T comparable]
Yöntem düzeyinde tür parametreleri yoktur; şablon özelleştirmesi yoktur

Sıkça Sorulan Sorular

“Genel Veri Yapıları” dersi ücretsiz mi?

Evet — “Genel Veri Yapıları” 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 Go Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Go Academy kursu toplamda 4 dersten oluşur.

“Genel Veri Yapıları” dersinde ne öğreneceğim?

Genel bir Stack ve Set oluşturma Go Academy 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.

Go Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Go Academy, 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 3. dersidir.

“Genel Veri Yapıları” 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 Go Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Go Academy 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

← Go Academy Sayfasına Dön