यहां पेड़ को समतल किए बिना इसे करने का एक तरीका है।
परिभाषा से, यहाँ,
data BinaryTree a = Null | Node (BinaryTree a) a (BinaryTree a)
deriving Show
एक देख सकते हैं कि पेड़ traversing बाएं से दाएं, अनदेखी Node
और कोष्ठक, आप में से एक वैकल्पिक अनुक्रम देता Null
है और a
रों। है यही कारण है, हर दो मानों के बीच, वहाँ एक है Null
।
मेरी योजना यह जांचना है कि प्रत्येक उपप्रकार उपयुक्त आवश्यकताओं को संतुष्ट करता है : हम प्रत्येक पर आवश्यकताओं को परिष्कृत कर सकते हैं Node
, यह याद रखते हुए कि हम किन मूल्यों के बीच हैं, फिर प्रत्येक पर उनका परीक्षण करें Null
। जैसा कि Null
मूल्यों की जोड़ी में प्रत्येक के बीच होता है, हमने परीक्षण किया होगा कि सभी क्रम में (बाएं से दाएं) जोड़े गैर-घटते हैं।
एक आवश्यकता क्या है? यह पेड़ में मूल्यों पर एक ढीला निचला और ऊपरी बाध्य है। आवश्यकताओं को व्यक्त करने के लिए, सबसे बाईं और दाईं ओर के सिरे सहित, हम Bot
टॉम और Top
तत्वों के साथ किसी भी क्रम का विस्तार कर सकते हैं , निम्नानुसार हैं:
data TopBot a = Bot | Val a | Top deriving (Show, Eq, Ord)
अब हम जाँचते हैं कि एक दिया गया पेड़ क्रम में और दिए गए सीमा के बीच दोनों की आवश्यकताओं को संतुष्ट करता है।
ordBetween :: Ord a => TopBot a -> TopBot a -> BinaryTree a -> Bool
-- tighten the demanded bounds, left and right of any Node
ordBetween lo hi (Node l x r) = ordBetween lo (Val x) l && ordBetween (Val x) hi r
-- check that the demanded bounds are in order when we reach Null
ordBetween lo hi Null = lo <= hi
एक द्विआधारी खोज पेड़ एक पेड़ है जो क्रम में और बीच में Bot
और है Top
।
isBSTree :: Ord a => BinaryTree a -> Bool
isBSTree = ordBetween Bot Top
प्रत्येक उपशीर्षक में वास्तविक चरम मूल्यों की गणना करते हुए , उन्हें बाहर की ओर बुदबुदाते हुए, आपको ज़रूरत से ज़्यादा जानकारी देता है, और किनारे के मामलों में फ़िज़ूल है जहाँ एक बाएँ या दाएँ सबट्री खाली है। आवश्यकताओं को बनाए रखना और जांचना , उन्हें अंदर की ओर धकेलना, बल्कि अधिक समान है।
flattenTree
पहले परिभाषित नहीं करेगा ।False
यदि कोई नोड उस नोड पर रूट किए गए पूरे सबट्री को पार किए बिना खोज प्रॉपर्टी का उल्लंघन करता है, तो आप जल्दी लौट सकते हैं ।