Kotlin में एल्गोरिदम और डेटा संरचनाएँ: एक संपूर्ण गाइड

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

Kotlin में एल्गोरिदम और डेटा संरचनाओं का परिचय

Kotlin एक आधुनिक प्रोग्रामिंग भाषा है जो संक्षिप्तता और शक्ति को जोड़ती है। Kotlin में एल्गोरिदम और डेटा संरचनाओं का अध्ययन कुशल और स्केलेबल कोड लिखने का मार्ग खोलता है। चाहे आप Android ऐप, बैकएंड सेवाएँ या डेस्कटॉप प्रोग्राम विकसित कर रहे हों, बुनियादी संरचनाओं और एल्गोरिदम को समझना किसी भी पेशेवर डेवलपर के लिए एक आवश्यक कौशल है।

इस लेख में, हम व्यावहारिक कोड उदाहरणों के साथ Kotlin में प्रमुख डेटा संरचनाओं और एल्गोरिदम पर चर्चा करेंगे। आप सीखेंगे कि सॉर्टिंग, सर्च, लिस्ट, स्टैक, क्यू, ट्री और ग्राफ़ के साथ कैसे काम करें।

1. Kotlin में बुनियादी डेटा संरचनाएँ

1.1. ऐरे और लिस्ट

Kotlin में, ऐरे को Array प्रकार द्वारा दर्शाया जाता है, और डायनामिक लिस्ट को List और MutableList द्वारा दर्शाया जाता है। लिस्ट सबसे अधिक उपयोग की जाने वाली डेटा संरचना है।

fun main() {    // अपरिवर्तनीय लिस्ट    val list: List<Int> = listOf(1, 2, 3, 4, 5)        // परिवर्तनीय लिस्ट    val mutableList: MutableList<Int> = mutableListOf(10, 20, 30)    mutableList.add(40)    mutableList.removeAt(0)        println(mutableList) // [20, 30, 40]}

1.2. स्टैक (Stack)

स्टैक LIFO (Last In, First Out) सिद्धांत पर काम करता है। Kotlin में, ArrayDeque का उपयोग करके स्टैक को लागू किया जा सकता है।

fun stackExample() {    val stack = ArrayDeque<String>()        stack.addLast("पहला")    stack.addLast("दूसरा")    stack.addLast("तीसरा")        println(stack.removeLast()) // तीसरा    println(stack.removeLast()) // दूसरा    println(stack.removeLast()) // पहला}

1.3. क्यू (Queue)

क्यू FIFO (First In, First Out) सिद्धांत पर काम करता है। कार्यान्वयन भी ArrayDeque का उपयोग करता है।

fun queueExample() {    val queue = ArrayDeque<Int>()        queue.addLast(1)    queue.addLast(2)    queue.addLast(3)        println(queue.removeFirst()) // 1    println(queue.removeFirst()) // 2    println(queue.removeFirst()) // 3}

1.4. लिंक्ड लिस्ट (LinkedList)

लिंक्ड लिस्ट नोड्स का एक अनुक्रम है, जिनमें से प्रत्येक में डेटा और अगले नोड का संदर्भ होता है। हम एक सरल सिंगली लिंक्ड लिस्ट लागू करते हैं।

class Node<T>(var value: T, var next: Node<T>? = null)

class LinkedList<T> {    private var head: Node<T>? = null        fun add(value: T) {        val newNode = Node(value)        if (head == null) {            head = newNode        } else {            var current = head            while (current?.next != null) {                current = current.next            }            current?.next = newNode        }    }        fun printAll() {        var current = head        while (current != null) {            print("${current.value} ")            current = current.next        }        println()    }}

fun main() {    val list = LinkedList<Int>()    list.add(10)    list.add(20)    list.add(30)    list.printAll() // 10 20 30}

2. Kotlin में सॉर्टिंग एल्गोरिदम

2.1. बबल सॉर्ट (Bubble Sort)

सरल, लेकिन अकुशल एल्गोरिदम। जटिलता O(n²) है।

fun bubbleSort(arr: MutableList<Int>) {    val n = arr.size    for (i in 0 until n - 1) {        for (j in 0 until n - i - 1) {            if (arr[j] > arr[j + 1]) {                val temp = arr[j]                arr[j] = arr[j + 1]                arr[j + 1] = temp            }        }    }}

fun main() {    val numbers = mutableListOf(64, 34, 25, 12, 22, 11, 90)    bubbleSort(numbers)    println(numbers) // [11, 12, 22, 25, 34, 64, 90]}