Kotlin में एल्गोरिदम और डेटा संरचनाएँ: एक व्यावहारिक मार्गदर्शिका

Here is the translated HTML content in Hindi, with all HTML tags preserved and only the text content translated. Programming terms, code examples, and proper nouns remain in English. ```html

Kotlin में एल्गोरिदम और डेटा संरचनाएँ: सिद्धांत से व्यवहार तक

Kotlin एक आधुनिक प्रोग्रामिंग भाषा है जो Python की संक्षिप्तता और Java की शक्ति को जोड़ती है। कुशल कोड लिखने के लिए यह समझना आवश्यक है कि एल्गोरिदम और डेटा संरचनाएँ कैसे काम करती हैं। इस लेख में, हम Kotlin उदाहरणों के साथ प्रमुख अवधारणाओं पर चर्चा करेंगे जो आपको तेज़ और विश्वसनीय प्रोग्राम लिखने में मदद करेंगे।

यह सामग्री शुरुआती और उन डेवलपर्स दोनों के लिए उपयोगी होगी जो अपने ज्ञान को व्यवस्थित करना चाहते हैं। सभी उदाहरण IntelliJ IDEA या ऑनलाइन कंपाइलर में चलाए जा सकते हैं।

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

Kotlin की मानक लाइब्रेरी डेटा संरचनाओं का एक समृद्ध सेट प्रदान करती है। आइए उनमें से कुछ प्रमुख पर नज़र डालें।

सूचियाँ (List, MutableList)

सूचियाँ तत्वों का क्रमबद्ध संग्रह हैं। Kotlin परिवर्तनीय और अपरिवर्तनीय सूचियों में अंतर करता है।

fun main() {    // अपरिवर्तनीय सूची    val fruits = listOf("Яблоко", "Банан", "Апельсин")        // परिवर्तनीय सूची    val numbers = mutableListOf(1, 2, 3)    numbers.add(4)    numbers.removeAt(1)        println(fruits[0]) // Яблоко    println(numbers)   // [1, 3, 4]}

समुच्चय (Set, MutableSet)

समुच्चय अद्वितीय तत्वों को संग्रहीत करते हैं। डुप्लिकेट की जाँच के लिए उपयोगी।

fun main() {    val uniqueNumbers = setOf(1, 2, 2, 3, 3, 3)    println(uniqueNumbers) // [1, 2, 3]        val mutableSet = mutableSetOf("a", "b")    mutableSet.add("c")    println(mutableSet.contains("b")) // true}

शब्दकोश (Map, MutableMap)

शब्दकोश कुंजी-मान जोड़े संग्रहीत करते हैं। हैश तालिका का एनालॉग।

fun main() {    val capitals = mapOf(        "Россия" to "Москва",        "США" to "Вашингтон",        "Франция" to "Париж"    )        println(capitals["Россия"]) // Москва        // परिवर्तनीय शब्दकोश    val scores = mutableMapOf("Иван" to 85)    scores["Мария"] = 92    scores["Иван"] = 90}

2. क्लासिक डेटा संरचनाओं का कार्यान्वयन

कभी-कभी मानक संरचनाएँ पर्याप्त नहीं होती हैं। आइए देखें कि स्टैक और क्यू को मैन्युअल रूप से कैसे लागू किया जाए।

स्टैक (Stack)

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

class Stack<T> {    private val elements = mutableListOf<T>()        fun push(item: T) = elements.add(item)    fun pop(): T? = if (isEmpty()) null else elements.removeAt(elements.size - 1)    fun peek(): T? = elements.lastOrNull()    fun isEmpty() = elements.isEmpty()    fun size() = elements.size}

fun main() {    val stack = Stack<Int>()    stack.push(10)    stack.push(20)    stack.push(30)        println(stack.pop())   // 30    println(stack.peek())  // 20    println(stack.size())  // 2}

क्यू (Queue)

क्यू FIFO (First In, First Out) सिद्धांत पर काम करता है। इसका उपयोग कार्य प्रसंस्करण प्रणालियों में किया जाता है।

class Queue<T> {    private val elements = mutableListOf<T>()        fun enqueue(item: T) = elements.add(item)    fun dequeue(): T? = if (isEmpty()) null else elements.removeAt(0)    fun peek(): T? = elements.firstOrNull()    fun isEmpty() = elements.isEmpty()}

fun main() {    val queue = Queue<String>()    queue.enqueue("Задача 1")    queue.enqueue("Задача 2")    queue.enqueue("Задача 3")        println(queue.dequeue()) // Задача 1    println(queue.peek())    // Задача 2}

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

सॉर्टिंग एक बुनियादी ऑपरेशन है। आइए तीन लोकप्रिय एल्गोरिदम पर चर्चा करें।

क्विक सॉर्ट (QuickSort)

सबसे कुशल एल्गोरिदम में से एक जिसकी औसत जटिलता O(n log n) है।

fun quickSort(arr: IntArray, low: Int, high: Int) {    if (low < high) {        val pi = partition(arr, low, high)        quickSort(arr, low, pi - 1)        quick
```