हाल ही में, मैंने अपने एल्गोरिदम/डेटा संरचना कौशल को बेहतर बनाने के लिए कुछ लीटकोड अभ्यासों का अभ्यास करना शुरू किया। मैं कह सकता हूं कि प्लेटफ़ॉर्म कई प्रोग्रामिंग भाषाओं में अन्य डेवलपर्स समाधानों के साथ अभ्यास करने और सीखने, चर्चा करने, दूसरों के साथ समाधान साझा करने और बड़ी कंपनियों द्वारा अनुरोधित कोड चुनौतियों का अभ्यास करने के लिए एक अच्छा वातावरण प्रदान करता है।

लीटकोड क्या है?

LeetCode एक वेबसाइट है जो उम्मीदवारों को कोडिंग साक्षात्कार के लिए तैयारी करने में मदद करती है। उपयोगकर्ता उम्मीदवार के समाधान के लिए पूर्वनिर्धारित परीक्षणों के साथ-साथ प्लेटफ़ॉर्म की कोडिंग और एल्गोरिथम समस्याओं का उपयोग करके चुनौतियों का अभ्यास कर सकते हैं। हैकररैंक के साथ-साथ लेटकोड तकनीकी साक्षात्कार और कोडिंग प्रतियोगिताओं के लिए एक लोकप्रिय संसाधन बन गया है।

मेरी दिनचर्या समस्याओं का समाधान करती है

मैंने खुद को प्रति दिन कम से कम 3 चुनौतियों को हल करने का लक्ष्य रखा है, और समाधान में मेरे सोचने के तरीके में मेरा आईपैड, स्क्रीन के लिए एक पेन और फ्रीफॉर्म ऐप शामिल है। मैं समाधान निकालने और उनके बारे में सोचने का प्रयास करता हूं, और इससे मेरे कोड सबमिशन में बहुत मदद मिल रही है। बहुत सारी चुनौतियाँ पहली नज़र में कठिन लगती हैं, लेकिन कुछ मिनटों के सोचने और समाधान तैयार करने के साथ (मैं आपकी सोचने की प्रक्रिया को लिखने की सलाह देता हूँ)। यदि मुझे 30 मिनट में सही समाधान नहीं मिल पाता है, तो मैं यह जानने के लिए अन्य डेवलपर्स के सबमिशन को देखता हूं कि मेरी गलतियां कहां हैं (कभी-कभी एक छोटा कदम जिसे मैं अपने कोड में भूल गया था)। भले ही आपका समाधान काफी अच्छा हो, मैं उस समस्या को हल करने के अन्य तरीकों (कुछ अधिक या कम कुशल) के बारे में सोचने के लिए दूसरों के सबमिशन को देखने की अत्यधिक अनुशंसा करता हूं।

इनवर्ट बाइनरी ट्री समस्या

कुछ दिन पहले मुझे लीटकोड में इनवर्ट बाइनरी ट्री समस्या का सामना करना पड़ा, यह कुछ साक्षात्कारों में अनुरोध की गई एक प्रसिद्ध चुनौती थी और एक समस्या जो मैंने विश्वविद्यालय में डेटा स्ट्रक्चर्स/एल्गोरिदम कक्षाएं लेते समय देखी थी। हालाँकि मुझे साक्षात्कार में कभी भी इस चुनौती का सामना नहीं करना पड़ा और मुझे कभी भी अपने काम में किसी बाइनरी ट्री को स्पष्ट रूप से उलटना नहीं पड़ा, लेकिन एक को कैसे उल्टा करना है, यह जानने से मुझे डीएस, ट्रीज़ और एल्गोरिदम सोच के साथ और अधिक अनुभव मिला और रिकर्सन जैसी कुछ तकनीकों का अभ्यास हुआ।
मैं आपको इस लेख का शेष भाग पढ़ने से पहले इस समस्या को हल करने का प्रयास करने की सलाह देता हूं

समाधान

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

Input: root = [4,2,7,1,3,6,9]
Output: [4,7,2,9,6,3,1]

हम पेड़ के कुछ हिस्से को जड़ के रूप में पास करते हुए, इनवर्टट्री() विधि को पुनरावर्ती रूप से कॉल करने के लिए रिकर्सन तकनीक का उपयोग करने जा रहे हैं। इसलिए, जैसा कि प्रत्येक रिकर्सन पूछता है, हमें एक स्टॉप कंडीशन को परिभाषित करने की आवश्यकता है जहां रिकर्सन स्टैक समाप्त हो जाएगा और रिकर्सन कॉल के संबंधित परिणाम लौटाएगा। इसके बाद, हम बस पेड़ के किनारों को उलट देते हैं, रूट.लेफ्ट को रिकर्सन द्वारा लौटाए गए मान को पैरामीटर के रूप में रूट.राइट पास करते हुए निर्दिष्ट करते हैं, और रूट.लेफ्ट रिकर्सन परिणाम का मान निर्दिष्ट करते हुए रूट.राइट के लिए भी ऐसा ही करते हैं। चूंकि हम मूल मान को संशोधित कर रहे हैं, हमें root.left के मूल परिणाम को संग्रहीत करने के लिए एक सहायक चर की आवश्यकता है (आपने शायद विश्वविद्यालय में इस तरह का एक कोड लागू किया है और इसे स्वैप() विधि कहा है।

अंत में हम उलटे नोड्स के साथ रूट लौटाते हैं। आप नीचे दिए गए कोड की जांच कर सकते हैं:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }

        TreeNode aux = root.left;
        root.left = invertTree(root.right);
        root.right = invertTree(aux);

        return root;
    }
}

ध्यान रखें कि विभिन्न समस्याओं के लिए कई अलग-अलग समाधान मौजूद हो सकते हैं, और यह बहुत अच्छा है। हर किसी के पास सोचने का एक तरीका और प्रोग्राम, डेटा स्ट्रक्चर डोमेन आदि होता है। इस समस्या को हल करने के लिए आपको बिल्कुल उसी कोड का पालन करने की आवश्यकता नहीं है, लेकिन आपको एल्गोरिदम जटिलता पर ध्यान देना होगा (आप किसी समस्या को हल करने के लिए 3 नेस्टेड का उपयोग कर सकते हैं) , लेकिन यह 1 का उपयोग करने की तुलना में कम प्रदर्शनात्मक है)।