द्विआधारी पेड़ - कोड के माध्यम से ट्रेसिंग

Question

द्विआधारी पेड़ - कोड के माध्यम से ट्रेसिंग

वोट

0

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

                                   60
                                 /    \
                                30     90
                               /  \   / 
                              5   38  77
                               \  /  / \
                               8 32 62  88



struct treeNode{
  int data;
  struct treeNode *left, *right:
  {

struct treeNode *tree_ptr;

void A(struct treeNode *node_ptr){
    if (node_ptr != NULL){
    printf(“%d ,”,node_ptr->data);
    B(node_ptr->left);
    B(node_ptr->right);
   }   
}

void B(struct treeNode *node_ptr){
    if (node_ptr != NULL) {
    A(node_ptr->left);
    printf(“%d ,”,node_ptr->data);
    A(node_ptr->right);
   }
 }

उत्तर: शून्य एक में यह पहला प्रिंट node_ptr-> डेटा तो 60 प्रिंट हो करने के लिए कहते हैं तो फिर समारोह बी (node_ptr-> बाएं) कहता है तो बी के भीतर, एक बुलाया जाता है (node_ptr-> बाएं) तो आप प्रिंट है कि डेटा जो 5 । और फिर एक (node_ptr-> सही) कहा जाता हो जाता है वापस एक, प्रिंट है कि डेटा तो 8 प्रिंट हो तक जा। अब मैं इतना यकीन नहीं आगे क्या करना है, लेकिन मैं तार्किक उसका प्रिंट ले मतलब होगा प्राप्त 30 लेकिन मैं यकीन नहीं कैसे ptr 8 से 30 करने के लिए और फिर अगर आप एक ही पैटर्न 38 में जारी मुद्रित किया जाता है और 32 प्रिंट हो जाता है। सही सबट्री के लिए ... 90 77 62 88

c algorithm data-structures binary-search-tree

14/12/2010 को 22:05
का स्रोत उपयोगकर्ता kachilous

अन्य भाषाओं में...

4 जवाब

वोट

1

शुरुआत के लिए, अपने कोड में त्रुटियों की एक गुच्छा है। मेरा अनुमान है कि यह इस तरह अधिक होना चाहिए:

struct treeNode{
  int data;
  struct treeNode *left, *right;
}

treeNode *tree_ptr;

void A(treeNode *node_ptr){
    if (node_ptr != NULL){  /// this could be just if(node_ptr)
        printf(“%d ,”,node_ptr->data);
        B(node_ptr->left);
        B(node_ptr->right);
    }   
}

void B(treeNode *node_ptr){
    if (node_ptr != NULL) {
        A(node_ptr->left);
        printf(“%d ,”,node_ptr->data);
        A(node_ptr->right);
    }
}

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

14/12/2010 को 22:11
का स्रोत उपयोगकर्ता Dav3

वोट

1

बस समय पर पूरा निष्पादन ढेर बाहर लिखें। इस कदर:

A(60)
  printf
  B(30)
    A(5)
      ...
    printf
    A(38)
      ...
  B(90)
    ...

(पेड़ पाठक के लिए एक व्यायाम के रूप में छोड़ के शेष।)

तो बस ऊपर से नीचे तक जाना, printf बयान के परिणाम लिखने।

14/12/2010 को 22:14
का स्रोत उपयोगकर्ता jdmichal

वोट

1

60, 30, 5, 8, 35, 32 आदि में - - 5, 8, 30, 32, 35 आदि का पता लगाने के रूप में ऊपर संकेत या तो अभी प्री-ऑर्डर के लिए, या इन-आदेश पूर्व सही नहीं किया जा सकता

28/03/2011 को 09:59
का स्रोत उपयोगकर्ता Brian

Vivin Paliath · Accepted Answer · 2010-12-14 22:15

Aएक पूर्व आदेश ट्रावर्सल जबकि है, Bएक में आदेश ट्रावर्सल है।

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

अद्यतन करें

कारण 30 5 के बाद बाहर मुद्रित हो जाता है और 8 है कि आप एक विशुद्ध रूप से प्री-ऑर्डर ट्रेवर्सल प्रदर्शन नहीं कर रहे है। आप एक पूर्व आदेश और एक में आदेश ट्रावर्सल के बीच कूद रहे हैं।

एक आसान तरीका है आदेश यह पता लगाने की वास्तव में (मैं अक्सर जानकारी को एक साथ रखने के लिए कलम / पेंसिल और कागज का उपयोग करें) चरण आपके कोड आप इसके माध्यम से पता लगाने के रूप में माध्यम से चला जाता लिख है। उदाहरण के लिए, आप को लिखने के इस तरह एक कॉल-ढेर कर सकता है:

A(60)
  printf(60)
  call B(60.left)
    B(30)
      call A(30.left)
        A(5)
          printf(5)
          call B(5.left)
            B(null)
          call B(5.right)
            B(8)
              call A(8.left)
                A(null)
              printf(8)
              call A(8.right)
                A(null)
      printf(30)
      call A(30.right)
        A(38)
        ...

आप आसानी से जिस क्रम में नोड्स मुद्रित कर रहे हैं, और अधिक महत्वपूर्ण बात, तुम क्यों मुद्रण 30 (एक पुनरावर्ती कॉल समाप्त हो गई और तुम वापस एक स्तर गिरने कर रहे हैं) के लिए 8 मुद्रण से "कूद" देख सकते हैं।