Kotlin ile Veri Yapıları ve Algoritmalar

Adı : Kotlin ile Veri Yapıları ve Algoritmalar

Veri yapıları ve algoritmalar, programlama dünyasında önemli bir konudur. Herhangi bir programcı, bu konuda bilgi sahibi değilse, programlama dünyasında başarılı olamaz. Kotlin, son yıllarda hızla popülerleşen bir programlama dili olmuştur. Kotlin ile veri yapıları ve algoritmaları öğrenmek, her programcının yapması gereken bir görevdir. Bu makalede, Kotlin ile veri yapıları ve algoritmalar hakkında detaylı bir şekilde ele alınacaktır.
Kotlin Veri Tipleri
Kotlin, bilinen birçok programlama dilinden farklı olarak Null değerlerine izin verir. Bu nedenle, veri yapıları ve algoritmalar bağlamında Null değerlerini de ele almamız gerekiyor.
- Byte: 8 bit işaretli tamsayı.\n- Short: 16 bit işaretli tamsayı.\n- Int: 32 bit işaretli tamsayı.\n- Long: 64 bit işaretli tamsayı.\n- Float: 32 bit ondalık sayı.\n- Double: 64 bit ondalık sayı.\n- Boolean: true ve false değerlerini alabilen veri tipi.\n- Char: tek bir karakteri temsil eden veri tipi.\n- String: bir dizeyi temsil eden veri tipi.
Kotlin’de Veri Yapıları
Veri yapıları, bir programlama dili içindeki verilerin örgüsünü veya organizasyonunu ifade eder. Veri yapıları, verilerin erişim hızını veya bellek kullanımını etkileyebilir.
Diziler
Diziler, aynı türdeki elemanları saklamak için kullanılan bir veri yapısıdır. Her eleman bir indeksle erişilebilir.
```kotlin\nval sayilar = intArrayOf(1, 2, 3, 4, 5)\nprintln(1. eleman: ${sayilar[0]}) // 1. eleman: 1\n```
Listenin Boyutunu Veri Olarak Kullanmak
Kotlin’de arr.size kullanarak, bir dizi başına veya bir dizinin elemanlarına erişerek, bir dizi boyutu için veri olarak kullanılabilir.
```kotlin\nfun main() { \n val dizi = arrayOf(1, 2, 3, 4, 5)\n println(Dizinin Boyutu : ${dizi.size}) // Dizinin Boyutu : 5 \n}\n```
Null Değerlerine İzin Veren Diziler
Kotlin’de null değerlere izin veren bir dizi oluşturmanız gerekiyorsa, arrayOfNulls () yöntemini kullanabilirsiniz.
```kotlin\nfun main() {\n val dizi: Array = arrayOfNulls(5)\n dizi[0] = A\n dizi[1] = null\n dizi[2] = B\n dizi[3] = null\n dizi[4] = C\n for (i in dizi) {\n println(i)\n }\n}\n```
Listenin Sonuna Eleman Eklemek
Bir diziye öğe eklemek için, öğeleri geçici bir liste içinde depolayabilir ve daha sonra orijinal listeye erişerek listenin sonuna ekleme işlemi yapabilirsiniz.
```kotlin\nfun main() {\n val dizi = arrayOf(1, 2, 3, 4, 5)\n val geciciDizi = dizi.toMutableList()\n geciciDizi.add(6)\n println(Yeni Dizi : $geciciDizi) // Yeni Dizi : [1, 2, 3, 4, 5, 6]\n}\n```
Linked List
Linked List, elemanların her birinin ayrı bir veri yapısı bağlantısına sahip olduğu veri yapılarından biridir. Bu nedenle, ekleme, silme ve erişim çok daha basittir.
```kotlin\nclass Dugum(var veri:Int){\n var sonraki:Dugum? = null\n}
class BagListe {\n var baslangic:Dugum? = null\n var son:Dugum? = null
fun elemanEkle(veri:Int){\n val dugum = Dugum(veri)
if(baslangic == null){\n baslangic = dugum\n son = dugum\n } else {\n son?.sonraki = dugum\n son = dugum\n }\n }
fun elemanlariListele(){\n var gecici = baslangic\n while (gecici != null){\n println(${gecici.veri})\n gecici = gecici.sonraki\n }\n }\n}
fun main(args: Array) {\n var liste = BagListe()
liste.elemanEkle(5)\n liste.elemanEkle(10)\n liste.elemanEkle(15)\n liste.elemanEkle(20)
liste.elemanlariListele()\n}\n```
Stack (Yığın)
Stack, en üstteki öğenin öncelikle çıkarıldığı bir veri yapısıdır. Bu, son giren ilk çıkar (LIFO) düzeninde çalışır.
```kotlin\nclass Yigin(private val kapasite: Int){
private val elemanlar: MutableList = mutableListOf()
fun push(eleman: Int) {\n if(elemanlar.size < kapasite){\n elemanlar.add(eleman)\n } else {\n throw StackOverflowError( Yığın dolu )\n }\n }\n fun pop() {\n if(elemanlar.isEmpty()){\n throw EmptyStackException()\n }\n elemanlar.removeAt(elemanlar.size - 1)\n } \n fun bosmu(): Boolean {\n return elemanlar.isEmpty()\n }\n}
fun main() {\n val yigin = Yigin(10)
yigin.push(1)\n yigin.push(2)\n yigin.push(3)\n yigin.push(4)\n yigin.push(5)
while(!yigin.bosmu()){\n println(yigin.pop())\n }\n} \n```
Queues (Kuyruk)
Kuyruk, ilk giren ilk çıkar (FIFO) ilkesine göre çalışır. Bu veri yapısı, sıraya birkaç öğe ekleyebilir ve sıradan öğeleri çıkarmak için çıkarma işleminin yapıldığı sıralı bir yapı kullanır.
```kotlin\nclass Kuyruk(private val kapasite: Int){
private val elemanlar: MutableList = mutableListOf()
fun ekle(eleman: Int) {\n if(elemanlar.size < kapasite){\n elemanlar.add(eleman)\n } else {\n throw IndexOutOfBoundsException(Kuyruk dolu)\n }\n }
fun sil() {\n if (elemanlar.isNotEmpty()){\n elemanlar.removeAt(0)\n }\n }
fun ilkEleman(): Int {\n return elemanlar[0]\n }
fun bosmu(): Boolean {\n return elemanlar.isEmpty()\n }\n}
fun main() {\n val kuyruk = Kuyruk(10)
kuyruk.ekle(1)\n kuyruk.ekle(2)\n kuyruk.ekle(3)\n kuyruk.ekle(4)
while(!kuyruk.bosmu()){\n println(kuyruk.ilkEleman())\n kuyruk.sil()\n }\n}\n```
Algoritmalar
Bir programlama dilinde veri yapılarının kullanımı kadar algoritmalar da önemlidir. Algoritmalar, programlama dilinin temeli olarak kabul edilir. Aşağıda, Kotlin ile algoritma örneklerine bakalım:
Bir Dizideki Elemanları Toplama
Bir dizideki elemanları toplamak için, for döngüsü kullanarak her bir elemanı geçici değişkenle toplayabiliriz.
```kotlin\nfun main() {\n val dizim = intArrayOf(1, 2, 3, 4, 5)\n var toplam = 0\n for(i in dizim){\n toplam += i\n }\n println(Toplam: $toplam) // Toplam: 15\n}\n```
Bir Sayının Faktöriyelini Bulmak
Bir sayının faktöriyelini hesaplamak için, bir sayı verildiğinde, bu sayıya kadar olan her sayının çarpımıdır.
```kotlin\nfun faktoriyel(sayi: Int): Int {\n var sonuc = 1\n for(i in 1..sayi){\n sonuc *= i\n }\n return sonuc\n}
fun main() {\n val num = 5\n val faktoriyel = faktoriyel(num)\n println(Faktoriyel: $faktoriyel) // Faktoriyel: 120\n}\n```
Girilen Sayıya Kadar Olan Tüm Asal Sayıları Bulmak
Asal sayıları bulmak için, girilen sayıya kadar olan tüm sayıları kontrol etmemiz gerekir. Çift sayılar asla asal değildir, dolayısıyla 2’den başladığımızdan emin olunmalıyız.
```kotlin\nfun main() {\n val max = 50\n var asal = true
for (i in 2..max) {\n for (j in 2 until i) {\n if (i % j == 0) {\n asal = false\n break\n }\n }\n if (asal) {\n println(i)\n }\n asal = true\n }\n}\n```
Sonuç
Kotlin, veri yapıları ve algoritmalar için birçok seçenek sunar. Özellikle null değerleri ile çalışırken, veri yapıları görselleştirilerek ve algoritmalar dikkate alınarak kullanılmalıdır. Bu makalede, Kotlin’in veri yapıları ve algoritmaları için bazı örnekler verdik. Kendi projenize fayda sağlamak için daha fazla araştırma yapmanız önemlidir.