यह सवाल एक साक्षात्कार में मुझसे पूछा गया था:
कहते हैं की सुविधा देता है हम द्विआधारी पेड़ के ऊपर है, मैं कैसे नीचे की तरह एक उत्पादन का उत्पादन कर सकते हैं
2 7 5 2 6 9 5 11 4
मैं की तरह हो सकता है कि हम एक स्तर गिनती चर है और प्रत्येक नोड के स्तर गिनती चर की जाँच करके क्रमिक रूप से सभी तत्वों को मुद्रित कर सकते हैं जवाब दे दिया। शायद मैं गलत था।
किसी को भी हम चाहते हैं कि कैसे प्राप्त कर सकते हैं के रूप में anyidea दे सकते हैं?
अपने प्रश्न में ट्रेवर्सल एक कहा जाता है level-order traversalऔर यह है कि यह कैसे (बहुत सरल / साफ कोड स्निपेट मैंने पाया) किया है है।
आप मूल रूप से एक कतार और संचालन के क्रम कुछ इस तरह दिखेगा का उपयोग करें:
enqueue F
dequeue F
enqueue B G
dequeue B
enqueue A D
dequeue G
enqueue I
dequeue A
dequeue D
enqueue C E
dequeue I
enqueue H
dequeue C
dequeue E
dequeue H
इस पेड़ (विकिपीडिया से सीधे) के लिए:
उस के लिए शब्द है स्तर से आदेश ट्रावर्सल । विकिपीडिया का वर्णन करता है कि एक कतार प्रयोग करने के लिए एक एल्गोरिथ्म :
levelorder(root)
q = empty queue
q.enqueue(root)
while not q.empty do
node := q.dequeue()
visit(node)
if node.left ≠ null
q.enqueue(node.left)
if node.right ≠ null
q.enqueue(node.right)
BFS :
std::queue<Node const *> q;
q.push(&root);
while (!q.empty()) {
Node const *n = q.front();
q.pop();
std::cout << n->data << std::endl;
if (n->left)
q.push(n->left);
if (n->right)
q.push(n->right);
}
Iterative मजबूत बनाने में भी काम करेगा और स्मृति उपयोग बचाता है, लेकिन कंप्यूटिंग समय की कीमत पर।
आप पेड़ की एक चौड़ाई पहले ट्रेवर्सल करने की ज़रूरत है। यहाँ यह इस प्रकार के रूप में वर्णित किया गया है:
चौड़ाई-पहले ट्रेवर्सल: गहराई-प्रथम एक पेड़ के तत्वों के माध्यम से जाने के लिए एकमात्र तरीका नहीं है। एक और तरीका है उन के माध्यम से जाने के लिए स्तर-दर-स्तर पर है।
उदाहरण के लिए, प्रत्येक तत्व पेड़ में एक निश्चित स्तर (या गहराई) पर मौजूद है:
tree
----
j <-- level 0
/ \
f k <-- level 1
/ \ \
a h z <-- level 2
\
d <-- level 3
0. के साथ शुरू संख्या बातें करने के लिए जैसे लोगों)
तो, हम तत्वों स्तर-दर-स्तर (और बाएँ से सही, हमेशा की तरह) की यात्रा करना चाहते हैं, तो हम जे के साथ 0 स्तर पर शुरू होगा, तो एफ और कश्मीर के लिए स्तर 1 पर जाएं, फिर स्तर 2 पर जाने के लिए एक, ज और z के लिए, और अंत में घ के लिए 3 स्तर पर जाने।
यह स्तर-दर-स्तर ट्रेवर्सल एक चौड़ाई-पहले ट्रेवर्सल कहा जाता है क्योंकि हम गहरा जाने से पहले एक दिया स्तर पर चौड़ाई, यानी, पेड़ की पूरी चौड़ाई का पता लगाने, कर रहा है।
मैं एक संग्रह है, जैसे प्रयोग करेंगे std::listवर्तमान में मुद्रित स्तर के सभी तत्वों को स्टोर करने के लिए,:
आप एक साक्षात्कार में क्या कर सकते हैं अगर आप याद नहीं है / "आधिकारिक" एल्गोरिथ्म पता नहीं है का एक उदाहरण के रूप में, मेरा पहला विचार था - नियमित रूप से प्री-ऑर्डर के साथ एक स्तर काउंटर खींच में पेड़ पार, एक को बनाए रखने संकेत की लिंक्ड सूचियों का वेक्टर स्तर प्रति नोड के लिए, उदाहरण के लिए
levels[level].push_back(&node);
और अंत में प्रत्येक स्तर की सूची मुद्रित करें।
हम एक ही स्तर पर अगले तत्व लाने के लिए सक्षम हैं, तो हम किया जाता है। के अनुसार हमारे पूर्व ज्ञान है, हम चौड़ाई पहले ट्रेवर्सल का उपयोग कर इन तत्व पहुँच सकते हैं।
अब केवल एक समस्या यह है कि कैसे अगर हम किसी भी स्तर पर पिछले तत्व पर हैं जाँच करने के लिए है। इस कारण से, हम एक सीमांकक (इस मामले में शून्य) एक स्तर के अंत चिह्नित करने के लिए जोड़कर किया जाना चाहिए।
एल्गोरिथ्म: 1. कतार में रखें जड़।
2. कतार में रखें शून्य।
3. जबकि कतार खाली नहीं है
4. एक्स = कतार से पहले तत्व लाने
5. यदि x शून्य नहीं है
6. x-> rpeer <= कतार में शीर्ष तत्व।
7. डाल छोड़ दिया और कतार में एक्स के सही बच्चे
किसी और 8.
9. अगर कतार खाली नहीं है
10 पुट शून्य कतार में
11. अगर अंत
12. अंत जबकि
13. वापसी
#include <queue>
void print(tree* root)
{
queue<tree*> que;
if (!root)
return;
tree *tmp, *l, *r;
que.push(root);
que.push(NULL);
while( !que.empty() )
{
tmp = que.front();
que.pop();
if(tmp != NULL)
{
cout << tmp=>val; //print value
l = tmp->left;
r = tmp->right;
if(l) que.push(l);
if(r) que.push(r);
}
else
{
if (!que.empty())
que.push(NULL);
}
}
return;
}