🚜 ◽️ 👩🏿‍🏭 पुस्तक "एल्गोरिदम और डेटा संरचनाएं। जावा सूचना पुनर्प्राप्ति

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

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

अंश "ट्री वॉक"

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

खोज इंजन

Google खोज या बिंग जैसे खोज इंजन, खोज शब्दों का एक सेट स्वीकार करता है और उन वेब पृष्ठों की सूची देता है जो इन शर्तों के लिए प्रासंगिक हैं। आप थिंकडैस्ट डॉट कॉम पर अधिक पढ़ सकते हैं, लेकिन मैं आपको बताऊंगा कि आपको क्या चाहिए।

एक खोज इंजन के मुख्य घटकों पर विचार करें।

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

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

पहले चरण के रूप में, हम एक खोज रोबोट बनाएंगे जो विकिपीडिया पृष्ठ को पढ़ता है, पहला लिंक पाता है, दूसरे पृष्ठ पर जाता है और पिछले चरणों को दोहराता है। हम इस खोज इंजन का उपयोग गेटिंग टू फिलॉसफी परिकल्पना का परीक्षण करने के लिए करेंगे। यह कहता है:

"विकिपीडिया लेख के मुख्य पाठ में पहले निचले लिंक पर क्लिक करके और फिर बाद के लेखों के लिए इस क्रिया को दोहराते हुए, आपको दर्शन पर एक लेख के साथ पृष्ठ पर ले जाने की संभावना है।"

आप इस परिकल्पना और इसके इतिहास को थिंकस्टैस्ट डॉट कॉम पर देख सकते हैं ।
एक परिकल्पना का परीक्षण आपको पूरे इंटरनेट या यहां तक कि पूरे विकिपीडिया को बायपास करने की आवश्यकता के बिना एक खोज रोबोट के मुख्य भागों को बनाने की अनुमति देगा। और मुझे लगता है कि यह अभ्यास काफी दिलचस्प है!

कई अध्यायों में, हम अनुक्रमणिका पर काम करेंगे, और फिर खोज इंजन पर आगे बढ़ेंगे।

HTML पार्सिंग

जब आप किसी वेब पेज को लोड करते हैं, तो उसकी सामग्री हाइपरटेक्स्ट मार्कअप लैंग्वेज (एचटीएमएल) में लिखी जाती है। उदाहरण के लिए, निम्नलिखित एक साधारण HTML दस्तावेज़ है:

<!DOCTYPE html> <html> <head> <title>This is a title</title> </head> <body> <p>Hello world!</p> </body> </html>

वाक्यांश यह एक शीर्षक और नमस्ते दुनिया है! ("नमस्ते दुनिया!") - पाठ जो वास्तव में पृष्ठ पर दिखाई देता है; अन्य तत्व यह दर्शाते हैं कि पाठ को कैसे प्रदर्शित किया जाना चाहिए।

पृष्ठ लोड करते समय, हमारे रोबोट को टेक्स्ट निकालने और लिंक खोजने के लिए HTML कोड को पार्स करने की आवश्यकता होती है। ऐसा करने के लिए, हम jsoup का उपयोग करेंगे, एक खुला स्रोत जावा पुस्तकालय जिसे लोडिंग और पार्सिंग (पार्सिंग) HTML के लिए डिज़ाइन किया गया है।
HTML पार्सिंग का परिणाम एक DOM (डॉक्यूमेंट ऑब्जेक्ट मॉडल) वृक्ष है जिसमें टेक्स्ट और टैग सहित दस्तावेज़ तत्व होते हैं।

एक पेड़ एक संबंधित डेटा संरचना है जिसमें कोने शामिल होते हैं जो पाठ, टैग और दस्तावेज़ के अन्य तत्वों का प्रतिनिधित्व करते हैं।

कोने के बीच का संबंध दस्तावेज़ की संरचना से निर्धारित होता है। पिछले उदाहरण में, पहला नोड, जिसे रूट कहा जाता है, एक टैग है जिसमें दो वर्टिकल के लिंक शामिल होते हैं और; ये नोड मूल नोड के बच्चे हैं।

एक नोड में एक चाइल्ड वर्टेक्स होता है, और एक नोड में एक चाइल्ड वर्टेक्स होता है

(पैराग्राफ, अंग्रेजी से। पैराग्राफ)। अंजीर में। 6.1 इस वृक्ष का चित्रमय निरूपण है।

प्रत्येक शीर्ष पर उसके बच्चे के नोड्स के लिंक शामिल हैं; इसके अलावा, प्रत्येक नोड में अपने माता-पिता के लिए एक लिंक होता है, जिससे आप किसी भी नोड से पेड़ को ऊपर और नीचे ले जा सकते हैं। वास्तविक पृष्ठों के लिए DOM ट्री आमतौर पर वर्णित उदाहरण की तुलना में अधिक जटिल है।

अधिकांश ब्राउज़रों के पास आपके द्वारा देखे जा रहे पृष्ठ के DOM की जाँच करने के लिए उपकरण हैं। Chrome में, आप वेब पेज के किसी भी भाग पर राइट-क्लिक कर सकते हैं और दिखाई देने वाले मेनू में कोड देखें आइटम का चयन कर सकते हैं। फ़ायरफ़ॉक्स में, आप राइट-क्लिक कर सकते हैं और संदर्भ मेनू से एक्सप्लोर आइटम का चयन कर सकते हैं। सफ़ारी वेब इंस्पेक्टर टूल प्रदान करता है, जो थिंकडास्ट . com / safari पर स्थित है। इंटरनेट एक्सप्लोरर के निर्देशों को लिंक पर क्लिक करके पढ़ा जा सकता है: Thinkdast.com/explorer ।

अंजीर में। चित्र 6.2 जावा के बारे में विकिपीडिया पृष्ठ के लिए DOM ट्री का स्क्रीनशॉट दिखाता है। हाइलाइट किया गया तत्व आलेख के मुख्य भाग का पहला पैराग्राफ है, जो <div> एलिमेंट के साथ तत्व = "mw-content-text" में निहित है। हम इस तत्व पहचानकर्ता का उपयोग हमारे द्वारा अपलोड किए गए प्रत्येक लेख के शरीर को निर्धारित करने के लिए करेंगे।

Jsoup आवेदन

Jsoup लाइब्रेरी वेब पेजों को लोड और विश्लेषण करना और DOM ट्री नेविगेट करना आसान बनाता है। उदाहरण के लिए:

 String url = "http://en.wikipedia.org/wiki/Java_(programming_language)"; //     Connection conn = Jsoup.connect(url); Document doc = conn.get(); //         Element content = doc.getElementById("mw-content-text"); Elements paragraphs = content.select("p");

Jsoup.connect तत्व URL को एक स्ट्रिंग के रूप में स्वीकार करता है और वेब सर्वर से कनेक्शन स्थापित करता है; पाने का तरीका HTML कोड को लोड करता है, इसे पार्स करता है, और एक डॉक्यूमेंट ऑब्जेक्ट देता है, जो एक DOM है।

इस ऑब्जेक्ट में एक पेड़ को नेविगेट करने और नोड्स का चयन करने के तरीके शामिल हैं। वास्तव में, यह इतने सारे तरीके प्रदान करता है कि यह भ्रमित हो सकता है। निम्न उदाहरण नोड्स का चयन करने के दो तरीके प्रदर्शित करता है।

getElementByld एक स्ट्रिंग प्रकार पैरामीटर लेता है और संबंधित आईडी फ़ील्ड के साथ तत्व के लिए एक पेड़ की तलाश करता है। इसे पाकर, वह नोड <div id = "mw-content-text" lang = "en" dir = "ltr" वर्ग = "mw-content-ltr"> का चयन करता है जो तत्व की पहचान करने के लिए प्रत्येक विकिपीडिया पृष्ठ पर दिखाई देता है। साइड नेविगेशन बार और अन्य तत्वों के विपरीत, पृष्ठ का मुख्य भाग <div> युक्त है।
चयन एक स्ट्रिंग लेता है, पेड़ का पता लगाता है, और स्ट्रिंग से मेल खाते टैग के साथ सभी तत्वों को वापस करता है। इस उदाहरण में, यह उन सभी पैराग्राफ टैगों को लौटाता है जो सामग्री में दिखाई देते हैं। वापसी मान प्रकार तत्वों का एक उद्देश्य है।

जारी रखने से पहले, आपको इन कक्षाओं के लिए दस्तावेज़ीकरण की समीक्षा करनी चाहिए ताकि यह पता चल सके कि वे क्या कार्य कर सकते हैं। सबसे महत्वपूर्ण वर्ग एलीमेंट, एलीमेंट्स और नोड हैं, जिन्हें आप थिंकस्टैस्ट . com/ jsoupelt , thinkdast.com/jsoupelts, और thinkdast.com/jsoupnode लिंक पर क्लिक करके पढ़ सकते हैं।

डोम ट्री में नोड क्लास सबसे ऊपर है। ऐसे कई उपवर्ग हैं जो नोड का विस्तार करते हैं, जिसमें तत्व, टेक्स्टनोड, डेटानेट और टिप्पणी शामिल हैं। एलिमेंट्स क्लास, एलीमेंट प्रकार की वस्तुओं का एक संग्रह है।

अंजीर में। 6.3 यूएमएल वर्गों का एक चित्र है जो उनके बीच के संबंधों को दर्शाता है। खाली तीर वाली एक रेखा एक वर्ग से दूसरे वर्ग के विस्तार को इंगित करती है। उदाहरण के लिए, यह चार्ट इंगित करता है कि तत्व ArrayList का विस्तार करते हैं। हम अध्याय 11 में इसी नाम के खंड में यूएमएल श्रेणी के आरेखों पर लौटेंगे।

एक डोम पेड़ पर पाले सेओढ़ लिया

आपके जीवन को आसान बनाने के लिए, मैं एक विकिनोडेलेबल क्लास प्रदान करता हूं जो आपको DOM ट्री के माध्यम से चलने की अनुमति देता है। निम्नलिखित एक उदाहरण है जो दिखाता है कि इस वर्ग का उपयोग कैसे करें:

 Elements paragraphs = content.select("p"); Element firstPara = paragraphs.get(0); Iterable<Node> iter = new WikiNodeIterable(firstPara); for (Node node: iter) { if (node instanceof TextNode) { System.out.print(node); } }

यह उदाहरण उस क्षण से शुरू होता है जिस पर पहले वाला रुका था। वह पैराग्राफ में पहले पैराग्राफ का चयन करता है और फिर एक विकेन्नेटरटेबल क्लास बनाता है जो इटरटेबल इंटरफ़ेस को लागू करता है। यह वर्ग गहराई से खोज करता है, जिससे वे पृष्ठ पर दिखाई देने वाले क्रम में नोड बनाते हैं।

वर्तमान उदाहरण में, हम केवल नोड प्रदर्शित करते हैं यदि यह एक TextNode है, और इसके अन्य प्रकारों को अनदेखा करता है, विशेष रूप से, टाइप तत्व की वस्तुएं जो टैग का प्रतिनिधित्व करती हैं। परिणाम बिना किसी मार्कअप के सादा HTML पैरा टेक्स्ट है। उनका निष्कर्ष:

जावा एक सामान्य प्रयोजन की कंप्यूटर प्रोग्रामिंग भाषा है जो समवर्ती, वर्ग-आधारित, वस्तु-उन्मुख, [13] है और विशेष रूप से डिज़ाइन की गई है ...

जावा एक सार्वभौमिक कंप्यूटर प्रोग्रामिंग भाषा है, जो समानांतर प्रोग्रामिंग [13] की संभावना के साथ, कक्षाओं पर आधारित एक वस्तु-उन्मुख भाषा है और विशेष रूप से ...

गहराई खोज

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

गहराई से खोज को लागू करने के दो आम तौर पर स्वीकृत तरीके हैं: पुनरावर्ती और पुनरावृत्ति। पुनरावर्ती कार्यान्वयन सरल और सुरुचिपूर्ण है:

 private static void recursiveDFS(Node node) { if (node instanceof TextNode) { System.out.print(node); } for (Node child: node.childNodes()) { recursiveDFS(child); } }

इस विधि को जड़ में शुरू होने वाले पेड़ के प्रत्येक नोड के लिए कहा जाता है। यदि Node एक TextNode है, तो इसकी सामग्री मुद्रित होती है। यदि नोड में बच्चे हैं, तो यह उनमें से प्रत्येक के लिए पुनरावर्ती डीएफएस कहता है।

वर्तमान उदाहरण में, हम प्रत्येक टेक्स्टनोड की सामग्री को उसके चाइल्ड नोड्स पर जाने से पहले प्रिंट करते हैं, अर्थात यह प्रत्यक्ष (प्री-ऑर्डर) ट्रैवर्सल का एक उदाहरण है। आप थिंकडस्ट . com/treetrav लिंक पर जाकर डायरेक्ट, रिवर्स (पोस्ट-ऑर्डर) और सिमिट्रिक (इन-ऑर्डर) वर्कआर्ड के बारे में पढ़ सकते हैं। इस एप्लिकेशन के लिए, क्रॉल ऑर्डर मायने नहीं रखता है।

पुनरावर्ती कॉल करते समय, बच्चे के कोने को ट्रैक करने और उन्हें सही क्रम में संसाधित करने के लिए recursiveDFS कॉल स्टैक ( थिंकडस्ट.com/callstack देखें) का उपयोग करता है। वैकल्पिक रूप से, आप नोड्स को ट्रैक करने के लिए स्टैक डेटा संरचना का उपयोग कर सकते हैं; यह पुनरावृत्ति और पेड़ पर पुनरावृति से बचना होगा।

जावा में ढेर

गहराई की खोज के पुनरावृत्त संस्करण की व्याख्या करने से पहले, मैं स्टैक की डेटा संरचना को देखूंगा। हम स्टैक की सामान्य अवधारणा के साथ शुरू करते हैं, और फिर दो जावा-इंटरफेस के बारे में बात करते हैं जो स्टैक के तरीकों को परिभाषित करते हैं: स्टैक और डेक्स।

स्टैक एक सूची-जैसी डेटा संरचना है: यह एक संग्रह है जो तत्वों के क्रम को बनाए रखता है। स्टैक और सूची के बीच मुख्य अंतर यह है कि पूर्व में कम विधियां शामिल हैं। सम्मेलन द्वारा, स्टैक विधियाँ प्रदान करता है:

स्टैक के शीर्ष पर एक तत्व जोड़ने, धक्का;
पॉप, जो निष्कासन करता है और स्टैक के सबसे ऊपरी तत्व का मान लौटाता है;
झांकना, ढेर को बदलने के बिना ढेर के सबसे ऊपरी तत्व को वापस करना;
ismmpty, जो इंगित करता है कि स्टैक खाली है या नहीं।

चूंकि पॉप हमेशा सबसे ऊपरी तत्व देता है, इसलिए स्टैक को LIFO भी कहा जाता है, जिसका अर्थ है "अंतिम रूप से, पहले बाहर"। स्टैक का एक विकल्प एक कतार है जो उसी क्रम में आइटम लौटाता है जिसमें उन्हें जोड़ा गया था, अर्थात, "पहले में, पहले बाहर", या फीफो।

पहली नज़र में, यह स्पष्ट नहीं है कि स्टैक और कतार उपयोगी क्यों हैं: वे कोई विशेष सुविधाएँ प्रदान नहीं करते हैं जो सूचियों से प्राप्त नहीं की जा सकती हैं; वास्तव में, उनके पास और भी कम अवसर हैं। तो हमेशा सूची क्यों नहीं लागू होती है? ढेर और कतारों को सही ठहराने के दो कारण हैं।

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

2. यदि डेटा संरचना एक छोटा एपीआई प्रदान करती है, तो इसे कुशलता से लागू करना आसान है। उदाहरण के लिए, स्टैक को लागू करने का एक सरल तरीका एकल सूची का उपयोग करना है। स्टैक पर एक आइटम को धक्का देना, हम इसे सूची के शीर्ष पर जोड़ते हैं; एक तत्व को पॉपिंग करते हुए, हम इसे शुरू से ही हटा देते हैं। एक लिंक की गई सूची के लिए, शुरुआत से जोड़ना और निकालना एक निरंतर समय ऑपरेशन है, इसलिए यह कार्यान्वयन प्रभावी है। इसके विपरीत, कुशलता से लागू करने के लिए बड़े एपीआई अधिक कठिन होते हैं।

जावा में स्टैक को लागू करने के तीन तरीके हैं।

1. ArrayList या LinkedList लागू करें। ArrayList का उपयोग करते समय, आपको अंत से जोड़ने और हटाने के लिए याद रखने की आवश्यकता होती है ताकि ये ऑपरेशन निरंतर समय में किए जाएं। गलत जगह आइटम जोड़ने से बचें या उन्हें गलत क्रम में हटा दें।

2. जावा में एक स्टैक वर्ग है जो स्टैक विधियों का एक मानक सेट प्रदान करता है। लेकिन यह वर्ग जावा का एक पुराना हिस्सा है: यह जावा संग्रह फ्रेमवर्क के साथ असंगत है, जो बाद में दिखाई दिया।

3. संभवतः सबसे अच्छा विकल्प Deque इंटरफ़ेस के कार्यान्वयन में से एक का उपयोग करना है, उदाहरण के लिए ArrayDeque।

ड्यूक एक डबल-एंडेड कतार से बनता है, जिसका अर्थ है "दो-तरफा कतार।" जावा में, Deque इंटरफ़ेस पुश, पॉप, पीक और इस्मेटिक तरीके प्रदान करता है, इसलिए इसे स्टैक के रूप में उपयोग किया जा सकता है। इसमें अन्य विधियां शामिल हैं, जिनके बारे में जानकारी थिंकस्टैस्ट.कॉम पर उपलब्ध है, लेकिन अब हम उनका उपयोग नहीं करेंगे।

Iterative गहराई खोज

निम्नलिखित डीएफएस का एक पुनरावृत्त संस्करण है जो नोड-प्रकार की वस्तुओं के ढेर का प्रतिनिधित्व करने के लिए एरियरडेक का उपयोग करता है:

 private static void iterativeDFS(Node root) { Deque<Node> stack = new ArrayDeque<Node>(); stack.push(root); while (!stack.isEmpty()) { Node node = stack.pop(); if (node instanceof TextNode) { System.out.print(node); } List<Node> nodes = new ArrayList<Node>(node. chiidNodesQ); Collections.reverse(nodes); for (Node child: nodes) { stack.push(chiid); } } }

रूट पैरामीटर उस पेड़ की जड़ है जिसे हम बायपास करना चाहते हैं, इसलिए हम एक स्टैक बनाकर और इस पैरामीटर को इसमें जोड़कर शुरू करते हैं।

स्टैक खाली होने तक लूप जारी रहता है। प्रत्येक पास स्टैक से नोड को बाहर धकेलता है। यदि एक TextNode प्राप्त होता है, तो इसकी सामग्री मुद्रित होती है। फिर, स्टैक में बाल कोने जोड़ दिए जाते हैं। सही क्रम में वंशजों को संसाधित करने के लिए, आपको उन्हें रिवर्स ऑर्डर में स्टैक पर धकेलने की आवश्यकता है; यह बच्चे के कोने को एक ArrayList में कॉपी करके, तत्वों को फिर से व्यवस्थित करके, और फिर उल्टे ArrayList को पुनरावृत्त करके किया जाता है।
इन-डेप्थ सर्च के इन-डेप्थ वर्जन के फायदों में से एक यह है कि जावा में इटरेटर के रूप में इसे लागू करना अधिक आसान है; ऐसा कैसे करें यह अगले अध्याय में बताया गया है।

लेकिन सबसे पहले, Deque इंटरफ़ेस पर एक अंतिम नोट: ArrayDeque के अलावा, जावा, हमारे पुराने मित्र लिंक्डलिस्ट को Deque का एक और कार्यान्वयन प्रदान करता है। उत्तरार्द्ध दोनों इंटरफेस को लागू करता है: सूची और Deque। परिणामी इंटरफ़ेस इसके उपयोग पर निर्भर करता है। उदाहरण के लिए, जब एक Deque चर से LinkedList असाइन करते हैं:

 Deqeue<Node> deque = new LinkedList<Node>();

आप Deque इंटरफ़ेस से विधियाँ लागू कर सकते हैं, लेकिन सूची इंटरफ़ेस से सभी विधियाँ नहीं। इसे चर सूची में निर्दिष्ट करके:

 List<Node> deque = new LinkedList<Node>();

आप सूची विधियों का उपयोग कर सकते हैं, लेकिन सभी विधियाँ विधियाँ नहीं। और उन्हें निम्नानुसार असाइन करना:

 LinkedList<Node> deque = new LinkedList<Node>();

सभी तरीकों का इस्तेमाल किया जा सकता है। लेकिन जब विभिन्न इंटरफेस से तरीकों को जोड़ते हैं, तो कोड कम पठनीय और अधिक त्रुटि प्रवण होगा।

»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर पाई जा सकती है
» सामग्री
» अंश

जावा फ़ार्मेन्टर्स - जावा के लिए कूपन पर 20% की छूट

पुस्तक "एल्गोरिदम और डेटा संरचनाएं। जावा सूचना पुनर्प्राप्ति »