चौड़ाई पहले बनाम गहराई पहले

Question

जब एक ट्री / ग्राफ को ट्रेस किया जाता है तो चौड़ाई प्रथम और गहराई के बीच क्या अंतर होता है? कोई भी कोडिंग या स्यूडोकोड उदाहरण महान होगा।

Comments

क्या आपने विकिपीडिया ( गहराई पहले , चौड़ाई पहले ) की जांच की? उन पृष्ठों पर कोड उदाहरण हैं, साथ ही बहुत सारे सुंदर चित्र हैं।

— rmeador

मुझे लगता है कि यह भी सोचा था, लेकिन उसके बाद दिए गए उदाहरण विकिपीडिया पर पाए जाने वाले की तुलना में थोड़ा अच्छे हैं ....

— jonnybazookatone

Answer 1

ये दो शब्द एक पेड़ पर चलने के दो अलग-अलग तरीकों के बीच अंतर करते हैं।

यह सिर्फ अंतर प्रदर्शित करने के लिए शायद सबसे आसान है। पेड़ पर विचार करें:

    A
   / \
  B   C
 /   / \
D   E   F

इस क्रम में एक गहराई वाला पहला ट्रैवर्स नोड्स का दौरा करेगा

A, B, D, C, E, F

ध्यान दें कि आप सभी तरह से नीचे जाते हैं आगे बढ़ने से पहले एक पैर से जाते हैं।

इस क्रम में एक चौड़ाई वाला पहला ट्रैवेल नोड का दौरा करेगा

A, B, C, D, E, F

यहाँ हम पूरे रास्ते काम करते हैं नीचे जाने से पहले प्रत्येक स्तर।

(ध्यान दें कि ट्रैवर्सल ऑर्डर में कुछ अस्पष्टता है, और मैंने पेड़ के प्रत्येक स्तर पर "पढ़ने" के आदेश को बनाए रखने के लिए धोखा दिया है। या तो मामले में मैं सी से पहले या बाद में बी ले सकता हूं, और इसी तरह मुझे मिल सकता है। एफ से पहले या बाद में एफ। यह बात हो सकती है या नहीं, आप आवेदन पर निर्भर करते हैं ...)

---

दोनों प्रकार के ट्रैवर्सल को स्यूडोकोड के साथ प्राप्त किया जा सकता है:

Store the root node in Container
While (there are nodes in Container)
   N = Get the "next" node from Container
   Store all the children of N in Container
   Do some work on N

दो ट्रैवर्सल ऑर्डर के बीच का अंतर चुनाव में निहित है Container ।

• के लिये पहले गहराई के एक ढेर का उपयोग करें। (पुनरावर्ती कार्यान्वयन कॉल-स्टैक का उपयोग करता है ...)
• के लिए चौड़ाई-पहले एक कतार का उपयोग करें।

---

पुनरावर्ती कार्यान्वयन जैसा दिखता है

ProcessNode(Node)
   Work on the payload Node
   Foreach child of Node
      ProcessNode(child)
   /* Alternate time to work on the payload Node (see below) */

जब आप किसी ऐसे बच्चे के पास नहीं पहुंचते हैं, तो पुनरावृत्ति समाप्त हो जाती है, इसलिए यह परिमित, चक्रीय ग्राफ के लिए समाप्त होने की गारंटी है।

---

इस बिंदु पर, मैंने अभी भी थोड़ा धोखा दिया है। थोड़ी चतुराई के साथ आप इस क्रम में नोड्स पर भी काम कर सकते हैं :

D, B, E, F, C, A

जो पहले गहराई का बदलाव है, जहां मैं प्रत्येक नोड पर काम नहीं करता जब तक कि मैं पेड़ पर वापस नहीं जा रहा हूं। हालांकि मैंने उनके बच्चों को खोजने के लिए नीचे के रास्ते पर उच्च नोड्स का दौरा किया है।

पुनरावर्ती कार्यान्वयन में यह ट्रैवर्सल काफी स्वाभाविक है (पहली "वर्क" लाइन के बजाय ऊपर "वैकल्पिक समय" लाइन का उपयोग करें), और बहुत कठिन नहीं है यदि आप एक स्पष्ट स्टैक का उपयोग करते हैं, लेकिन मैं इसे एक अभ्यास के रूप में छोड़ दूँगा।

Comments

@ मिकी धन्यवाद! मेरा मानना ​​है कि आप "नोड पर पेलोड पर काम करते हैं," सही है?

— बल्लेबाजी

यह ध्यान देने योग्य हो सकता है कि आप उपसर्ग प्राप्त करने के लिए गहराई-पहले संस्करण को संशोधित कर सकते हैं ( A, B, D, C, E, F- पहले वाला प्रस्तुत), infix ( D, B, A, E, C, F- छँटाई के लिए प्रयोग किया जाता है: एक AVL पेड़ के रूप में जोड़ें फिर infix पढ़ें) या पोस्टफ़िक्स ( D, B, E, F, C, Aवैकल्पिक प्रस्तुत) ट्रैवर्सल। नाम उस स्थिति से दिए गए हैं जिसमें आप रूट को संसाधित करते हैं। यह ध्यान दिया जाना चाहिए कि इन्फिक्स केवल द्विआधारी पेड़ों के लिए वास्तव में समझ में आता है। @batbrat वे नाम हैं ... जब से आपने पूछा था, तब से आपको पहले से ही पता है।

— थरोट

@ थरोट को इसमें जोड़ने के लिए धन्यवाद! हां, मुझे इस प्रकार के ट्रैवर्सल्स के बारे में पता है और इन्फ़िक्स केवल बाइनरी पेड़ों के लिए क्यों समझ में आता है।

— 9

कैसे तय करें कि किस समाधान में बेहतर स्थान या समय की जटिलता है?

— इगोरगानापोलस्की

@IgorGanapolsky सिद्धांत पर दोनों के लिए समान होना चाहिए (आखिरकार, वे अनिवार्य रूप से समान कोड का उपयोग करते हैं)। एक और दिलचस्प सवाल यह होगा कि वे कैश और वर्किंग सेट को कैसे प्रभावित करते हैं, लेकिन मुझे लगता है कि यह पेड़ की आकृति विज्ञान पर निर्भर करेगा।

— dmckee --- पूर्व-मध्यस्थ ने बिल्ली

Answer 2

शर्तों को समझना:

यह चित्र आप किस संदर्भ में शब्दों के बारे में पता चलना चाहिए कि चौड़ाई और गहराई किया जाता है।

---

गहराई-पहली खोज:

• डेप्थ-फर्स्ट सर्च एल्गोरिथ्म इस तरह से काम करता है जैसे कि वह शुरुआती बिंदु से जितना जल्दी हो सके उतना दूर जाना चाहता है।

• यह आम तौर पर Stackयाद करने के लिए एक का उपयोग करता है कि यह कहाँ जाना चाहिए जब यह एक मृत अंत तक पहुंचता है।

• पालन ​​करने के नियम: पहले शीर्ष को A पर पुश करें Stack

  1. यदि संभव हो तो, एक निकटवर्ती परिकल्पित शीर्ष पर जाएँ, इसे विज़िट के रूप में चिह्नित करें, और इसे स्टैक पर धक्का दें।
  2. यदि आप नियम 1 का पालन नहीं कर सकते हैं, तो, यदि संभव हो, तो स्टैक से एक शीर्ष को पॉप करें।
  3. यदि आप नियम 1 या नियम 2 का पालन नहीं कर सकते हैं, तो आप कर रहे हैं।

• जावा कोड:

  public void searchDepthFirst() {
      // Begin at vertex 0 (A)
      vertexList[0].wasVisited = true;
      displayVertex(0);
      stack.push(0);
      while (!stack.isEmpty()) {
          int adjacentVertex = getAdjacentUnvisitedVertex(stack.peek());
          // If no such vertex
          if (adjacentVertex == -1) {
              stack.pop();
          } else {
              vertexList[adjacentVertex].wasVisited = true;
              // Do something
              stack.push(adjacentVertex);
          }
      }
      // Stack is empty, so we're done, reset flags
      for (int j = 0; j < nVerts; j++)
          vertexList[j].wasVisited = false;
  }
  

• अनुप्रयोग : गहराई-पहली खोजों का उपयोग अक्सर खेलों के सिमुलेशन (और वास्तविक दुनिया में गेम जैसी स्थितियों) में किया जाता है। एक विशिष्ट खेल में आप कई संभावित कार्यों में से एक चुन सकते हैं। प्रत्येक विकल्प आगे की पसंद की ओर जाता है, जिनमें से प्रत्येक आगे की पसंद की ओर जाता है, और इसी तरह संभावनाओं के एक कभी-विस्तार वाले पेड़ के आकार के ग्राफ में।

---

पहले चौड़ाई खोजो:

• चौड़ाई-प्रथम खोज एल्गोरिथ्म शुरुआती बिंदु के जितना संभव हो उतना करीब रहना पसंद करता है।
• इस तरह की खोज आम तौर पर एक का उपयोग करके कार्यान्वित की जाती है Queue।
• पालन ​​करने के नियम: वर्टेक्स को वर्तमान वर्टेक्स बनाना शुरू करें
  1. अगले अनवीकृत वर्टेक्स पर जाएँ (यदि कोई है तो) जो वर्तमान वर्टेक्स के समीप है, तो उसे चिह्नित करें और उसे कतार में डालें।
  2. यदि आप नियम 1 को अंजाम नहीं दे सकते हैं, क्योंकि कोई और अधिक लंबवत वर्धमान नहीं हैं, तो कतार से एक शीर्ष हटा दें (यदि संभव हो) और इसे वर्तमान शीर्ष बना दें।
  3. यदि आप नियम 2 को पूरा नहीं कर सकते हैं क्योंकि कतार खाली है, तो आप कर रहे हैं।

• जावा कोड:

  public void searchBreadthFirst() {
      vertexList[0].wasVisited = true;
      displayVertex(0);
      queue.insert(0);
      int v2;
      while (!queue.isEmpty()) {
          int v1 = queue.remove();
          // Until it has no unvisited neighbors, get one
          while ((v2 = getAdjUnvisitedVertex(v1)) != -1) {
              vertexList[v2].wasVisited = true;
              // Do something
              queue.insert(v2);
          }
      }
      // Queue is empty, so we're done, reset flags
      for (int j = 0; j < nVerts; j++) 
          vertexList[j].wasVisited = false;
  }
  

• अनुप्रयोग : चौड़ाई-पहली खोज में पहले सभी किनारे पाए जाते हैं जो शुरुआती बिंदु से एक किनारे दूर होते हैं, फिर सभी कोने जो दो किनारों से दूर होते हैं, और इसी तरह। यह उपयोगी है अगर आप किसी दिए गए शीर्ष पर शुरू से शीर्ष तक सबसे छोटा रास्ता खोजने की कोशिश कर रहे हैं।

उम्मीद है कि चौड़ाई-पहले और गहराई-पहले खोजों को समझने के लिए पर्याप्त होना चाहिए। आगे पढ़ने के लिए मैं रॉबर्ट लॉफ द्वारा एक उत्कृष्ट डेटा स्ट्रक्चर्स बुक से ग्राफ्स अध्याय की सिफारिश करूंगा।

Comments

क्या मेरे पास दस और वोटिंग का अधिकार था, मैं ऐसा करूंगा।

— एसएनआर

@ एसएनआरआर आपको एक इनाम दे सकता है;)

— स्नो

@ अगर आप इसके निर्देश बताते हैं, तो मैं कर सकता हूं। मैं नहीं जानता कि कैसे करना है।

— एसएनआर

धन्यवाद @snr, मैं अपना पहला इनाम पाकर बहुत खुश हूं। मैं बहुत सराहना करता हूं।

— योगेश उमेश वैट

धन्यवाद @ पता है, मुझे खुशी है कि आप लोगों को मेरा उत्तर उपयोगी लगा।

— योगेश उमेश वैट

Answer 3

इस बाइनरी ट्री को देखते हुए:

चौड़ाई प्रथम ट्रैवर्सल:
बाएं से दाएं प्रत्येक स्तर पर पार।

"मैं जी हूं, मेरे बच्चे डी हैं और मैं, मेरे दादाजी बी, ई, एच और के हैं, उनके पोते ए, सी, एफ हैं"

- Level 1: G 
- Level 2: D, I 
- Level 3: B, E, H, K 
- Level 4: A, C, F

Order Searched: G, D, I, B, E, H, K, A, C, F

गहराई पहले ट्रैवर्सल:
ट्रावर्सल को एक बार में एसीआरओएसएस पूरे स्तर पर नहीं किया जाता है। इसके बजाय, पहले पेड़ की जड़ (पत्ती से पत्ती तक) में ट्रैवर्सल डाइव करता है। हालाँकि, यह थोड़ा ऊपर और नीचे की तुलना में थोड़ा अधिक जटिल है।

इसकी तीन विधियाँ हैं:

1) PREORDER: ROOT, LEFT, RIGHT.
You need to think of this as a recursive process:  
Grab the Root. (G)  
Then Check the Left. (It's a tree)  
Grab the Root of the Left. (D)  
Then Check the Left of D. (It's a tree)  
Grab the Root of the Left (B)  
Then Check the Left of B. (A)  
Check the Right of B. (C, and it's a leaf node. Finish B tree. Continue D tree)  
Check the Right of D. (It's a tree)  
Grab the Root. (E)  
Check the Left of E. (Nothing)  
Check the Right of E. (F, Finish D Tree. Move back to G Tree)  
Check the Right of G. (It's a tree)  
Grab the Root of I Tree. (I)  
Check the Left. (H, it's a leaf.)  
Check the Right. (K, it's a leaf. Finish G tree)  
DONE: G, D, B, A, C, E, F, I, H, K  

2) INORDER: LEFT, ROOT, RIGHT
Where the root is "in" or between the left and right child node.  
Check the Left of the G Tree. (It's a D Tree)  
Check the Left of the D Tree. (It's a B Tree)  
Check the Left of the B Tree. (A)  
Check the Root of the B Tree (B)  
Check the Right of the B Tree (C, finished B Tree!)  
Check the Right of the D Tree (It's a E Tree)  
Check the Left of the E Tree. (Nothing)  
Check the Right of the E Tree. (F, it's a leaf. Finish E Tree. Finish D Tree)...  
Onwards until...   
DONE: A, B, C, D, E, F, G, H, I, K  

3) POSTORDER: 
LEFT, RIGHT, ROOT  
DONE: A, C, B, F, E, D, H, K, I, G

उपयोग (उर्फ, हम क्यों परवाह करते हैं):
मैंने वास्तव में गहराई के पहले त्रैमासिक विधियों के इस सरल Quora स्पष्टीकरण का आनंद लिया और उनका आमतौर पर कैसे उपयोग किया जाता है:
"इन-ऑर्डर ट्रैवर्सल मूल्यों को प्रिंट करेगा [BST के लिए क्रम में (बाइनरी सर्च ट्री)] "
" प्री-ऑर्डर ट्रैवर्सल का उपयोग [बाइनरी सर्च ट्री] की एक प्रति बनाने के लिए किया जाता है। "
"पोस्टऑर्डर ट्रैवर्सल का उपयोग [बाइनरी सर्च ट्री] को हटाने के लिए किया जाता है।"
https://www.quora.com/What-is-the-use-of-pre-order-and-post-order-traversal-of-binary-trees-in-computing

Answer 4

मुझे लगता है कि दोनों को इस तरह से लिखना दिलचस्प होगा कि केवल कोड की कुछ पंक्तियों को स्विच करने से आपको एक एल्गोरिथ्म या दूसरा मिलेगा, जिससे आप देखेंगे कि आपका डिल्मा इतना मजबूत नहीं है जितना कि यह पहले लगता है ।

मुझे व्यक्तिगत रूप से बीएफएस की व्याख्या एक परिदृश्य की बाढ़ के रूप में पसंद है: कम ऊंचाई वाले क्षेत्रों में पहले बाढ़ आएगी, और उसके बाद ही ऊंचाई वाले क्षेत्रों का अनुसरण किया जाएगा। यदि आप भूगोल की किताबों में देखे जाने वाले परिदृश्यों को अलग-थलग करने की कल्पना करते हैं, तो यह देखना आसान है कि बीएफएस एक ही समय में एक ही आइसोलिन के तहत सभी क्षेत्र को भर देता है, जैसा कि यह भौतिकी के साथ होगा। इस प्रकार, दूरी या स्केल की गई लागत के रूप में ऊंचाई की व्याख्या एल्गोरिथ्म का एक बहुत सहज ज्ञान युक्त विचार देता है।

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

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

इसलिए, मेरे लिए झूठ के बीच का अंतर जो प्राकृतिक घटना वास्तविक जीवन में उनके प्रसार मॉडल (ट्रांसवर्सिंग) से सबसे अच्छा मेल खाता है।

Comments

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

— जुआनम्फ