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

परिचय: Kotlin में एल्गोरिदम और डेटा संरचनाएँ क्यों सीखें?

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

एक शुरुआत करने वाले के लिए यह क्यों आवश्यक है? पहला, बुनियादी संरचनाओं (सूचियाँ, स्टैक, क्यू, हैश टेबल) का ज्ञान अधिक कुशल और तेज़ कोड लिखने में मदद करता है। दूसरा, एल्गोरिदम साक्षात्कार में तकनीकी समस्याओं को हल करने का आधार हैं। तीसरा, यह बस दिलचस्प है: आप कोड के पीछे तर्क और गणित देखना शुरू करते हैं।

इस लेख में, हम Kotlin में प्रमुख एल्गोरिदम और डेटा संरचनाओं को शुरू से समझेंगे। सभी उदाहरण सरल, समझने योग्य और चलाने के लिए तैयार होंगे। चलिए शुरू करते हैं!

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

एरे और सूचियाँ

Kotlin में दो मुख्य प्रकार के कलेक्शन हैं: Array (निश्चित आकार) और List (गतिशील)। अधिकांश कार्यों के लिए List का उपयोग करना अधिक सुविधाजनक है।

fun main() {\n    // निश्चित आकार का एरे\n    val numbersArray = arrayOf(1, 2, 3, 4, 5)\n    println("एरे: ${numbersArray.joinToString()}")\n\n    // परिवर्तनीय सूची\n    val mutableList = mutableListOf(10, 20, 30)\n    mutableList.add(40)\n    println("जोड़ने के बाद सूची: $mutableList")\n\n    // अपरिवर्तनीय सूची\n    val immutableList = listOf(100, 200, 300)\n    println("अपरिवर्तनीय सूची: $immutableList")\n}

स्टैक (Stack)

स्टैक LIFO (Last In, First Out) सिद्धांत पर काम करता है — अंतिम आया, पहला गया। Kotlin में कोई अंतर्निहित Stack क्लास नहीं है, लेकिन इसे MutableList का उपयोग करके आसानी से लागू किया जा सकता है।

class Stack<T> {\n    private val elements = mutableListOf<T>()\n\n    fun push(item: T) = elements.add(item)\n    fun pop(): T? = if (isEmpty()) null else elements.removeAt(elements.size - 1)\n    fun peek(): T? = elements.lastOrNull()\n    fun isEmpty() = elements.isEmpty()\n    fun size() = elements.size\n}\n\nfun main() {\n    val stack = Stack<Int>()\n    stack.push(1)\n    stack.push(2)\n    stack.push(3)\n\n    println("शीर्ष तत्व: ${stack.peek()}") // 3\n    println("निकाल रहे हैं: ${stack.pop()}")        // 3\n    println("अब शीर्ष: ${stack.peek()}")  // 2\n}

क्यू (Queue)

क्यू FIFO (First In, First Out) सिद्धांत पर काम करता है — पहला आया, पहला गया। Kotlin में इसके लिए Java से LinkedList का उपयोग करना सुविधाजनक है।

import java.util.LinkedList\n\nclass Queue<T> {\n    private val elements = LinkedList<T>()\n\n    fun enqueue(item: T) = elements.add(item)\n    fun dequeue(): T? = elements.poll()\n    fun peek(): T? = elements.peek()\n    fun isEmpty() = elements.isEmpty()\n    fun size() = elements.size\n}\n\nfun main() {\n    val queue = Queue<String>()\n    queue.enqueue("पहला")\n    queue.enqueue("दूसरा")\n    queue.enqueue("तीसरा")\n\n    println("सेवा दे रहे हैं: ${queue.dequeue()}") // पहला\n    println("अगला: ${queue.peek()}")      // दूसरा\n}

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

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

सरल, लेकिन धीमा एल्गोरिदम। सीखने के लिए उपयुक्त है, लेकिन वास्तविक परियोजनाओं के लिए नहीं।

fun bubbleSort(arr: MutableList<Int>) {\n    val n = arr.size\n    for (i in 0 until n - 1) {\n        for (j in 0 until n - i - 1) {\n            if (arr[j] > arr[j + 1]) {\n                val temp = arr[j]\n                arr[j] = arr[j + 1]\n                arr[j + 1] = temp\n            }\n        }\n    }\n}\n\nfun main() {\n    val list = mutableListOf(64, 34, 25, 12, 22, 11, 90)\n    bubbleSort(list)\n    println("बबल सॉर्ट किया गया: $list")\n}

बी