कैसे निर्धारित करें कि बाइनरी ट्री संतुलित है?


113

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

मैं इसके साथ कुछ सोच रहा था:

public boolean isBalanced(Node root){
    if(root==null){
        return true;  //tree is empty
    }
    else{
        int lh = root.left.height();
        int rh = root.right.height();
        if(lh - rh > 1 || rh - lh > 1){
            return false;
        }
    }
    return true;
}

क्या यह एक अच्छा कार्यान्वयन है? या क्या मैं कुछ न कुछ भूल रहा हूं?


यदि आप एक ग्राफिक के साथ डोनल फेलो के अस्की
user7643681

1
अच्छा जवाब, मुझे अमेरिका में जाने में मदद मिली। (चुटकुले)
हेनरी

जवाबों:


165

कुछ और खोजते हुए इस पुराने प्रश्न से टकराया। मैंने ध्यान दिया कि आपको कभी भी पूर्ण उत्तर नहीं मिला।

इस समस्या को हल करने का तरीका उस फ़ंक्शन के लिए एक विनिर्देश लिखकर शुरू करना है जिसे आप लिखने की कोशिश कर रहे हैं।

विशिष्टता: एक अच्छी तरह से निर्मित बाइनरी ट्री को "ऊंचाई-संतुलित" कहा जाता है यदि (1) यह खाली है, या (2) इसके बाएं और दाएं बच्चे ऊंचाई-संतुलित हैं और बाएं पेड़ की ऊंचाई 1 के भीतर है सही पेड़ की ऊंचाई।

अब जब आपके पास विनिर्देश हैं, तो कोड लिखने के लिए तुच्छ है। बस विनिर्देश का पालन करें:

IsHeightBalanced(tree)
    return (tree is empty) or 
           (IsHeightBalanced(tree.left) and
            IsHeightBalanced(tree.right) and
            abs(Height(tree.left) - Height(tree.right)) <= 1)

अपनी पसंद की प्रोग्रामिंग भाषा में अनुवाद करना तुच्छ होना चाहिए।

बोनस अभ्यास : इस भोले कोड स्केच पेड़ को ऊंचाइयों की गणना करते समय कई बार बहुत पीछे छोड़ देता है। क्या आप इसे अधिक कुशल बना सकते हैं?

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

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

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

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


19
+1 केवल सही उत्तर के लिए, मैं विश्वास नहीं कर सकता कि कोई भी 8 महीने तक इसका जवाब देने में सक्षम नहीं था ...
ब्लूराजा - डैनी पफ्लुघोफ्ट

1
नीचे दिए गए "अभ्यास" का उत्तर ...
पोटाटोस्वर्ट

नीचे दिए गए बोनस अभ्यास का उत्तर दिया।
ब्रायन

नीचे sdk का उत्तर सही प्रतीत होता है और केवल 2 ट्री ट्रैवर्सल्स बनाता है इसलिए O (n) है। जब तक मैं सोमेथिनिग को याद नहीं कर रहा हूं, तब तक यह कम से कम आपके पहले बोनस प्रश्न को हल नहीं करता है। आप निश्चित रूप से गतिशील प्रोग्रामिंग और आपके समाधान का उपयोग मध्यवर्ती ऊंचाइयों को कैश करने के लिए कर सकते हैं
एली

सैद्धांतिक रूप से, मुझे अभी भी डोनल फेलो की परिभाषा का सामना करना होगा।
ध्रुव गरोला

26

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

एक पेड़ जहां किसी भी शाखा की अधिकतम ऊंचाई से अधिक नहीं है एक किसी भी शाखा की न्यूनतम ऊंचाई से अधिक है।

(यह वास्तव में तात्पर्य है कि शाखाएँ स्वयं संतुलित हैं; आप अधिकतम और न्यूनतम दोनों के लिए एक ही शाखा चुन सकते हैं।)

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

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

कोड में:

class Tree {
    Tree left, right;
    static interface Observer {
        public void before();
        public void after();
        public boolean end();
    }
    static boolean traverse(Tree t, Observer o) {
        if (t == null) {
            return o.end();
        } else {
            o.before();
            try {
                if (traverse(left, o))
                    return traverse(right, o);
                return false;
            } finally {
                o.after();
            }
        }
    }
    boolean balanced() {
        final Integer[] heights = new Integer[2];
        return traverse(this, new Observer() {
            int h;
            public void before() { h++; }
            public void after() { h--; }
            public boolean end() {
                if (heights[0] == null) {
                    heights[0] = h;
                } else if (Math.abs(heights[0] - h) > 1) {
                    return false;
                } else if (heights[0] != h) {
                    if (heights[1] == null) {
                        heights[1] = h;
                    } else if (heights[1] != h) {
                        return false;
                    }
                }
                return true;
            }
        });
    }
}

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


[संपादित करें]: आप प्रत्येक पक्ष की ऊंचाई क्यों नहीं ले सकते। इस पेड़ पर विचार करें:

        /\
       /  \
      /    \
     /      \_____
    /\      /     \_
   /  \    /      / \
  /\   C  /\     /   \
 /  \    /  \   /\   /\
A    B  D    E F  G H  J

ठीक है, थोड़ा गंदा है, लेकिन जड़ के प्रत्येक पक्ष संतुलित है: Cगहराई 2, है A, B, D, Eगहराई 3, और कर रहे हैं F, G, H, Jगहराई 4. बाईं शाखा की ऊंचाई रहे हैं 2 (ऊंचाई याद है कि आप के रूप में पार कम हो जाती है है शाखा), सही शाखा की ऊंचाई 3. है फिर भी कुल मिलाकर पेड़ है नहीं संतुलित रूप में वहाँ के बीच 2 की ऊंचाई में अंतर होता है Cऔर F। आपको एक न्यूनतम विनिर्देश की आवश्यकता होती है (हालांकि वास्तविक एल्गोरिथ्म कम जटिल हो सकता है क्योंकि केवल दो अनुमत ऊँचाई होनी चाहिए)।


आह, अच्छी बात है। आपके पास एक पेड़ हो सकता है जो h (LL) = 4, h (LR) = 3, h (RL) = 3, h (RR) = 2 है। इस प्रकार, एच (एल) = 4 और एच (आर) = 3, इसलिए यह पहले के एल्गोरिथ्म के लिए संतुलित दिखाई देगा, लेकिन 4/2 की अधिकतम / न्यूनतम गहराई के साथ, यह संतुलित नहीं है। यह शायद एक तस्वीर के साथ और अधिक समझ में आता है।
टिम अप

1
यही मैंने अभी जोड़ा है (दुनिया के सबसे नास्तिक ASCII ग्राफिक पेड़ के साथ)।
डोनाल्ड फेलो

@DonalFellows: आपने बाईं शाखा की ऊंचाई का उल्लेख किया है 2. लेकिन बाईं शाखा में जड़ और पत्ती सहित 4 नोड हैं। ऊंचाई इस मामले में 3 सही होगी
मस्तिष्क तूफान

22

यह केवल यह निर्धारित करता है कि पेड़ का शीर्ष स्तर संतुलित है या नहीं। यही है, आप एक पेड़ को दो लंबी शाखाओं के साथ दूर बाईं ओर और दाईं ओर, बीच में कुछ भी नहीं कर सकते हैं, और यह सच होगा। आपको पुन: जाँच करने root.leftऔर root.rightयह देखने की ज़रूरत है कि क्या सच में लौटने से पहले वे आंतरिक रूप से संतुलित हैं या नहीं।


हालाँकि, यदि कोड में एक अधिकतम और न्यूनतम ऊंचाई विधि थी, अगर यह विश्व स्तर पर संतुलित है, तो यह स्थानीय रूप से भी संतुलित होगा।
अरी

22

बोनस व्यायाम प्रतिक्रिया। सरल उपाय। स्पष्ट रूप से एक वास्तविक कार्यान्वयन में उपयोगकर्ता को उनकी प्रतिक्रिया में ऊंचाई को शामिल करने की आवश्यकता से बचने के लिए यह या कुछ लपेट सकता है।

IsHeightBalanced(tree, out height)
    if (tree is empty)
        height = 0
        return true
    balance = IsHeightBalanced(tree.left, heightleft) and IsHeightBalanced(tree.right, heightright)
    height = max(heightleft, heightright)+1
    return balance and abs(heightleft - heightright) <= 1     

यदि पेड़ कुछ सौ परतों से अधिक बड़ा है, तो आपको स्टैकओवरफ्लो अपवाद मिलता है। आपने इसे कुशलता से किया है, लेकिन यह मध्यम या बड़े आकार के डेटा सेट को संभालता नहीं है।
एरिक लेसचिंस्की

क्या यह छद्मकोड आपके साथ आया है या यह एक वास्तविक भाषा है? (मेरा मतलब है " out height" चर संकेतन)
kap

@kap: यह स्यूडोकोड है, लेकिन आउट सिंटैक्स C # से लिया गया है। मूल रूप से, इसका मतलब है कि पैरामीटर को बुलाया फ़ंक्शन से कॉलर तक जाता है (मानक मापदंडों के विपरीत, जो कॉलर से कॉल करने के लिए यात्रा करते हैं या मापदंडों को संदर्भित करते हैं, जो कॉल करने वाले से फ़ंक्शन और बैक तक यात्रा करते हैं)। यह प्रभावी रूप से फ़ंक्शन को एक से अधिक मान वापस करने की अनुमति देता है।
ब्रायन

20

पोस्ट ऑर्डर समाधान, पेड़ को केवल एक बार पार करें। समय जटिलता O (n) है, अंतरिक्ष O (1) है, यह टॉप-डाउन समाधान से बेहतर है। मैं आपको एक जावा संस्करण कार्यान्वयन देता हूं।

public static <T> boolean isBalanced(TreeNode<T> root){
    return checkBalance(root) != -1;
}

private static <T> int checkBalance(TreeNode<T> node){
    if(node == null) return 0;
    int left = checkBalance(node.getLeft());

    if(left == -1) return -1;

    int right = checkBalance(node.getRight());

    if(right == -1) return -1;

    if(Math.abs(left - right) > 1){
        return -1;
    }else{
        return 1 + Math.max(left, right);
    }
}

4
अच्छा समाधान, लेकिन अंतरिक्ष की जटिलता ओ (एच) होनी चाहिए जहां एच पेड़ की ऊंचाई है। ऐसा इसलिए है क्योंकि पुनरावृत्ति के लिए स्टैक आवंटन।
लेग्रास

क्या left == -1मतलब है? ऐसा कब होगा? क्या हम मानते हैं कि पुनरावर्ती कॉल का तात्पर्य यह left == -1है कि क्या सच है अगर बाएं बच्चों के सभी उपशीर्षक असंतुलित हैं?
एस्पेन

left == 1इसका मतलब है कि बायां सबट्री असंतुलित है, तो पूरा पेड़ असंतुलित है। हमें अब सही सबट्री की जांच करने की आवश्यकता नहीं है, और वापस आ सकते हैं -1
tning

समय जटिलता O (n) है क्योंकि आपको सभी तत्वों से गुजरना पड़ता है। और, यदि आपके पास x नोड्स थे और शेष राशि की जांच करने में y समय लगेगा; यदि आपके पास 2x नोड्स थे, तो संतुलन की जांच करने में 2y समय लगेगा। यह सब सही लगता है?
जैक

ड्राइंग के साथ अच्छी तरह से स्पष्टीकरण यहाँ है: एल्गोरिदम
टाइप्सहोरीज़ोन

15

एक ऊंचाई संतुलित बाइनरी ट्री की परिभाषा है:

बाइनरी ट्री जिसमें प्रत्येक नोड के दो उपप्रकारों की ऊंचाई कभी भी 1 से अधिक नहीं होती है।

तो, एक खाली बाइनरी ट्री हमेशा ऊंचाई-संतुलित होता है।
एक गैर-खाली बाइनरी ट्री ऊंचाई-संतुलित है यदि:

  1. इसका बायाँ उपरी भाग ऊँचाई-संतुलित है।
  2. इसका दाहिना उपरी भाग ऊँचाई से संतुलित है।
  3. बाएँ और दाएँ उपशीर्षक की ऊँचाई के बीच का अंतर 1 से अधिक नहीं है।

पेड़ पर विचार करें:

    A
     \ 
      B
     / \
    C   D

जैसा कि देखा गया है कि बाएं सबट्री Aऊँचाई-संतुलित है (जैसा कि यह खाली है) और इसलिए इसका सही सबट्री है। लेकिन अभी भी पेड़ ऊंचाई-संतुलित नहीं है क्योंकि हालत 3 को बाएं- 0उप- ऊंचाई की ऊंचाई के रूप में पूरा नहीं किया गया है और सही उप-पेड़ की ऊंचाई है 2

इसके अलावा, निम्नलिखित पेड़ ऊंचाई से संतुलित नहीं है, हालांकि बाएं और दाएं उप-पेड़ की ऊंचाई बराबर है। आपका मौजूदा कोड इसके लिए सही लौटेगा।

       A
     /  \ 
    B    C
   /      \
  D        G
 /          \
E            H

इसलिए हर शब्द में बहुत महत्वपूर्ण है।

यह काम करेगा:

int height(treeNodePtr root) {
        return (!root) ? 0: 1 + MAX(height(root->left),height(root->right));
}

bool isHeightBalanced(treeNodePtr root) {
        return (root == NULL) ||
                (isHeightBalanced(root->left) &&
                isHeightBalanced(root->right) &&
                abs(height(root->left) - height(root->right)) <=1);
}

Ideone लिंक


तो इस जवाब से मुझे बहुत मदद मिली। हालाँकि, मैंने पाया कि एल्गोरिदम कोर्स के लिए मुफ्त [एमआईटी इंट्रो] विरोधाभास स्थिति लगता है। पेज 4 एक आरबी पेड़ दिखाता है जहां बाईं शाखा की ऊंचाई 2 है और दाईं शाखा 4 है। क्या आप मुझे कुछ स्पष्टीकरण दे सकते हैं? शायद मुझे सबट्री की परिभाषा नहीं आती। [१]: ocw.mit.edu/courses/electrical-engineering-and-computer-science/…
i8abug

यह अंतर पाठ्यक्रम के नोट्स में इस परिभाषा से आता है। किसी भी नोड x से एक वंशज पत्ती तक के सभी सरल रास्तों में काले नोड्स = काले-ऊँचाई (x) की समान संख्या है
i8abug

बस फॉलो करने के लिए, मुझे एक परिभाषा मिली जो आपके प्रत्येक उत्तर में "हर पत्ती 'किसी भी अन्य पत्ती की तुलना में' एक निश्चित दूरी से अधिक नहीं 'है। यह दोनों मामलों को संतुष्ट करता है। यहाँ कुछ यादृच्छिक पाठ्यक्रम वेयर से लिंक है
i8abug

8

यदि बाइनरी ट्री संतुलित है या नहीं तो लेवल ऑर्डर ट्रैवर्सल द्वारा जाँच की जा सकती है:

private boolean isLeaf(TreeNode root) {
    if (root.left == null && root.right == null)
        return true;
    return false;
}

private boolean isBalanced(TreeNode root) {
    if (root == null)
        return true;
    Vector<TreeNode> queue = new Vector<TreeNode>();
    int level = 1, minLevel = Integer.MAX_VALUE, maxLevel = Integer.MIN_VALUE;
    queue.add(root);
    while (!queue.isEmpty()) {
        int elementCount = queue.size();
        while (elementCount > 0) {
            TreeNode node = queue.remove(0);
            if (isLeaf(node)) {
                if (minLevel > level)
                    minLevel = level;
                if (maxLevel < level)
                    maxLevel = level;
            } else {
                if (node.left != null)
                    queue.add(node.left);
                if (node.right != null)
                    queue.add(node.right);
            }
            elementCount--;
        }
        if (abs(maxLevel - minLevel) > 1) {
            return false;
        }
        level++;
    }

    return true;
}

1
बहुत बढ़िया जवाब। मुझे लगता है कि यह सभी आवश्यकताओं को पूरा करता है जो एरिक ने बोनस और सुपर-बोनस के बारे में पोस्ट किया है। यह पुनरावृत्ति (एक कतार का उपयोग करके) और पुनरावर्ती नहीं है - इसलिए कॉल-स्टैक अतिप्रवाह नहीं होगा और हम सभी मेमोरी-मुद्दों को ढेर करने के लिए स्थानांतरित करते हैं। इसके लिए पूरे पेड़ को ट्रेस करने की भी आवश्यकता नहीं होती है। यह स्तर के स्तर से आगे बढ़ता है, इसलिए यदि कोई पेड़ 1 तरफ से असंतुलित है, तो यह वास्तव में जल्द ही मिल जाएगा (सबसे अच्छा; सबसे पुनरावर्ती एल्गोरिदम की तुलना में जल्द ही, हालांकि आप एक पोस्ट-ऑर्डर ट्रैवर्सल पुनरावृत्ति एल्गोरिथ्म को लागू कर सकते हैं, जो अंतिम-स्तर मिलेगा) जल्द ही असंतुलित हो जाएगा, लेकिन पहले स्तरों पर गरीब कार्य करेगा)। तो +1 :-)
डेविड रेफेल

7

यह वास्तव में है की तुलना में अधिक जटिल तरीका बनाया जा रहा है।

एल्गोरिथ्म इस प्रकार है:

  1. A = उच्चतम स्तर के नोड की गहराई दें
  2. चलो बी = सबसे निचले स्तर के नोड की गहराई

  3. यदि एब्स (एबी) <= 1 है, तो पेड़ संतुलित है


सरल और सीधे!
वसीम थबरेज

3
दो समस्याएं, यह उतना कुशल नहीं है जितना यह हो सकता है, आप पूरे पेड़ पर दो पास बना रहे हैं। और उन पेड़ों के लिए जिनके पास एक नोड बाईं ओर है, और हजारों दाईं ओर, आप अनावश्यक रूप से पूरी चीज के माध्यम से कदम रखते हैं, जब आप 3 चेक के बाद रोक सकते थे।
एरिक लेसिंसकी

5

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

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


4

नोट 1: किसी भी उप-पेड़ की ऊंचाई केवल एक बार गणना की जाती है।

नोट 2: यदि बायां उप-वृक्ष असंतुलित है, तो दाएं उप-पेड़ की गणना, जिसमें संभावित रूप से मिलियन तत्व होते हैं, को छोड़ दिया जाता है।

// return height of tree rooted at "tn" if, and only if, it is a balanced subtree
// else return -1
int maxHeight( TreeNode const * tn ) {
    if( tn ) {
        int const lh = maxHeight( tn->left );
        if( lh == -1 ) return -1;
        int const rh = maxHeight( tn->right );
        if( rh == -1 ) return -1;
        if( abs( lh - rh ) > 1 ) return -1;
        return 1 + max( lh, rh );
    }
    return 0;
}

bool isBalanced( TreeNode const * root ) {
    // Unless the maxHeight is -1, the subtree under "root" is balanced
    return maxHeight( root ) != -1;
}

3

संतुलन आमतौर पर प्रत्येक दिशा पर सबसे लंबे पथ की लंबाई पर निर्भर करता है। उपरोक्त एल्गोरिथ्म आपके लिए ऐसा नहीं करने जा रहा है।

आप क्या लागू करने की कोशिश कर रहे हैं? चारों ओर स्व-संतुलन वाले पेड़ हैं (एवीएल / रेड-ब्लैक)। वास्तव में, जावा के पेड़ संतुलित हैं।


3

यदि यह आपकी नौकरी के लिए है , तो मेरा सुझाव है:

  1. पहिया को सुदृढ़ न करें और
  2. बिट्स के साथ फ़िडलिंग के बजाय COTS का उपयोग करें / खरीदें
  3. व्यावसायिक समस्याओं को हल करने के लिए अपना समय / ऊर्जा बचाएं।

3
public boolean isBalanced(TreeNode root)
{
    return (maxDepth(root) - minDepth(root) <= 1);
}

public int maxDepth(TreeNode root)
{
    if (root == null) return 0;

    return 1 + max(maxDepth(root.left), maxDepth(root.right));
}

public int minDepth (TreeNode root)
{
    if (root == null) return 0;

    return 1 + min(minDepth(root.left), minDepth(root.right));
}

मुझे लगता है कि यह समाधान सही नहीं है। यदि आप एक ऐसे पेड़ को पास करते हैं जिसमें एक नोड होता है यानी एक रूट जो इसे मैक्सडेपथ 1(मिनडिप के लिए समान) के रूप में लौटाएगा । हालांकि सही गहराई होनी चाहिए 0। एक पेड़ की जड़ में हमेशा 0गहराई होती है
क्रेटाइलस

3

यहां C # में पूर्ण रूप से काम किया गया परीक्षण समाधान है (क्षमा करें, मैं जावा देव नहीं हूं) (बस कंसोल ऐप में कॉपी पेस्ट करें)। मुझे पता है कि संतुलित की परिभाषा भिन्न होती है, इसलिए हर कोई मेरे परीक्षा परिणाम को पसंद नहीं कर सकता है, लेकिन कृपया एक पुनरावर्ती लूप में गहराई / ऊंचाई की जाँच करने के थोड़े अलग दृष्टिकोण को देखें और प्रत्येक नोड पर ऊंचाई / स्तर / गहराई को सहेजे बिना पहले बेमेल पर बाहर निकलें। (केवल एक फ़ंक्शन कॉल में इसे बनाए रखना)।

using System;
using System.Linq;
using System.Text;

namespace BalancedTree
{
    class Program
    {
        public static void Main()
        {
            //Value Gathering
            Console.WriteLine(RunTreeTests(new[] { 0 }));
            Console.WriteLine(RunTreeTests(new int[] { }));

            Console.WriteLine(RunTreeTests(new[] { 0, 1, 2, 3, 4, -1, -4, -3, -2 }));
            Console.WriteLine(RunTreeTests(null));
            Console.WriteLine(RunTreeTests(new[] { 10, 8, 12, 8, 4, 14, 8, 10 }));
            Console.WriteLine(RunTreeTests(new int[] { 20, 10, 30, 5, 15, 25, 35, 3, 8, 12, 17, 22, 27, 32, 37 }));

            Console.ReadKey();
        }

        static string RunTreeTests(int[] scores)
        {
            if (scores == null || scores.Count() == 0)
            {
                return null;
            }

            var tree = new BinarySearchTree();

            foreach (var score in scores)
            {
                tree.InsertScore(score);
            }

            Console.WriteLine(tree.IsBalanced());

            var sb = tree.GetBreadthWardsTraversedNodes();

            return sb.ToString(0, sb.Length - 1);
        }
    }

    public class Node
    {
        public int Value { get; set; }
        public int Count { get; set; }
        public Node RightChild { get; set; }
        public Node LeftChild { get; set; }
        public Node(int value)
        {
            Value = value;
            Count = 1;
        }

        public override string ToString()
        {
            return Value + ":" + Count;
        }

        public bool IsLeafNode()
        {
            return LeftChild == null && RightChild == null;
        }

        public void AddValue(int value)
        {
            if (value == Value)
            {
                Count++;
            }
            else
            {
                if (value > Value)
                {
                    if (RightChild == null)
                    {
                        RightChild = new Node(value);
                    }
                    else
                    {
                        RightChild.AddValue(value);
                    }
                }
                else
                {
                    if (LeftChild == null)
                    {
                        LeftChild = new Node(value);
                    }
                    else
                    {
                        LeftChild.AddValue(value);
                    }
                }
            }
        }
    }

    public class BinarySearchTree
    {
        public Node Root { get; set; }

        public void InsertScore(int score)
        {
            if (Root == null)
            {
                Root = new Node(score);
            }
            else
            {
                Root.AddValue(score);
            }
        }

        private static int _heightCheck;
        public bool IsBalanced()
        {
            _heightCheck = 0;
            var height = 0;
            if (Root == null) return true;
            var result = CheckHeight(Root, ref height);
            height--;
            return (result && height == 0);
        }

        private static bool CheckHeight(Node node, ref int height)
        {
            height++;
            if (node.LeftChild == null)
            {
                if (node.RightChild != null) return false;
                if (_heightCheck != 0) return _heightCheck == height;
                _heightCheck = height;
                return true;
            }
            if (node.RightChild == null)
            {
                return false;
            }

            var leftCheck = CheckHeight(node.LeftChild, ref height);
            if (!leftCheck) return false;
            height--;
            var rightCheck = CheckHeight(node.RightChild, ref height);
            if (!rightCheck) return false;
            height--;
            return true;
        }


        public StringBuilder GetBreadthWardsTraversedNodes()
        {
            if (Root == null) return null;
            var traversQueue = new StringBuilder();
            traversQueue.Append(Root + ",");
            if (Root.IsLeafNode()) return traversQueue;
            TraversBreadthWards(traversQueue, Root);
            return traversQueue;
        }

        private static void TraversBreadthWards(StringBuilder sb, Node node)
        {
            if (node == null) return;
            sb.Append(node.LeftChild + ",");
            sb.Append(node.RightChild + ",");
            if (node.LeftChild != null && !node.LeftChild.IsLeafNode())
            {
                TraversBreadthWards(sb, node.LeftChild);
            }
            if (node.RightChild != null && !node.RightChild.IsLeafNode())
            {
                TraversBreadthWards(sb, node.RightChild);
            }
        }
    }
}

मुझे समझ नहीं आ रहा है कि कोई व्यक्ति उत्तर देने के 2 मिनट के भीतर इस उत्तर को कैसे नकारात्मक वोट दे सकता है ?? नकारात्मक वोट ठीक है लेकिन क्या आप बता सकते हैं कि इस समाधान में क्या गलत है?
एसबीपी

2
#include <iostream>
#include <deque>
#include <queue>

struct node
{
    int data;
    node *left;
    node *right;
};

bool isBalanced(node *root)
{
    if ( !root)
    {
        return true;
    }

    std::queue<node *> q1;
    std::queue<int>  q2;
    int level = 0, last_level = -1, node_count = 0;

    q1.push(root);
    q2.push(level);

    while ( !q1.empty() )
    {
        node *current = q1.front();
        level = q2.front();

        q1.pop();
        q2.pop();

        if ( level )
        {
            ++node_count;
        }

                if ( current->left )
                {
                        q1.push(current->left);
                        q2.push(level + 1);
                }

                if ( current->right )
                {
                        q1.push(current->right);
                        q2.push(level + 1);
                }

        if ( level != last_level )
        {
            std::cout << "Check: " << (node_count ? node_count - 1 : 1) << ", Level: " << level << ", Old level: " << last_level << std::endl;
            if ( level && (node_count - 1) != (1 << (level-1)) )
            {
                return false;
            }

            last_level = q2.front();
            if ( level ) node_count = 1;
        }
    }

    return true;
}

int main()
{
    node tree[15];

    tree[0].left  = &tree[1];
    tree[0].right = &tree[2];
    tree[1].left  = &tree[3];
    tree[1].right = &tree[4];
    tree[2].left  = &tree[5];
    tree[2].right = &tree[6];
    tree[3].left  = &tree[7];
    tree[3].right = &tree[8];
    tree[4].left  = &tree[9];   // NULL;
    tree[4].right = &tree[10];  // NULL;
    tree[5].left  = &tree[11];  // NULL;
    tree[5].right = &tree[12];  // NULL;
    tree[6].left  = &tree[13];
    tree[6].right = &tree[14];
    tree[7].left  = &tree[11];
    tree[7].right = &tree[12];
    tree[8].left  = NULL;
    tree[8].right = &tree[10];
    tree[9].left  = NULL;
    tree[9].right = &tree[10];
    tree[10].left = NULL;
    tree[10].right= NULL;
    tree[11].left = NULL;
    tree[11].right= NULL;
    tree[12].left = NULL;
    tree[12].right= NULL;
    tree[13].left = NULL;
    tree[13].right= NULL;
    tree[14].left = NULL;
    tree[14].right= NULL;

    std::cout << "Result: " << isBalanced(tree) << std::endl;

    return 0;
}

आप कुछ टिप्पणियों को जोड़ना चाह सकते हैं
jgauffin

2

रे: @ एक बीएफएस का उपयोग करके एक स्तर-ऑर्डर ट्रैवर्सल के लिए भाग्यशाली समाधान।

हम पेड़ को पीछे छोड़ते हैं और var min / max-level का संदर्भ रखते हैं जो न्यूनतम स्तर का वर्णन करता है जिस पर एक नोड एक पत्ती है।

मेरा मानना ​​है कि @ लकी समाधान में संशोधन की आवश्यकता है। जैसा कि @codadict द्वारा सुझाया गया है, अगर नोड एक पत्ती है, तो यह जांचने के बजाय, हमें यह देखना चाहिए कि क्या EITHER बाएं या दाएं बच्चे शून्य है (दोनों नहीं)। अन्यथा, एल्गोरिथ्म इसे एक मान्य संतुलित वृक्ष मानता है:

     1
    / \
   2   4
    \   \
     3   1

पायथन में:

def is_bal(root):
    if root is None:
        return True

    import queue

    Q = queue.Queue()
    Q.put(root)

    level = 0
    min_level, max_level = sys.maxsize, sys.minsize

    while not Q.empty():
        level_size = Q.qsize()

        for i in range(level_size):
            node = Q.get()

            if not node.left or node.right:
                min_level, max_level = min(min_level, level), max(max_level, level)

            if node.left:
                Q.put(node.left)
            if node.right:
                Q.put(node.right)

        level += 1

        if abs(max_level - min_level) > 1:
            return False

    return True

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

वैकल्पिक रूप से, हम प्रारंभ में पेड़ को प्रत्येक रूट सबट्री के लिए + कैश अधिकतम हाइट्स की गणना करने के लिए पार कर सकते हैं। फिर एक और पुनरावृत्त रन में, जांचें कि क्या प्रत्येक रूट के लिए बाएं और दाएं की कैश्ड ऊंचाइयां कभी भी एक से अधिक भिन्न नहीं होती हैं। यह O (n) समय और O (n) स्पेस में भी चलेगा, लेकिन पुनरावृति के कारण स्टैक ओवरफ्लो नहीं होगा।


1

ठीक है, आपको बाएं और दाएं की ऊंचाइयों को निर्धारित करने के लिए एक तरीका चाहिए, और यदि बाएं और दाएं संतुलित हैं।

और मैं बस return height(node->left) == height(node->right);

एक heightफ़ंक्शन लिखने के रूप में , पढ़ें: पुनरावृत्ति को समझना


3
आप बाएं और दाएं ऊंचाइयों को 1 के भीतर होना चाहते हैं, जरूरी नहीं कि समान हो।
एलेक्स बी

1

आप किस पेड़ की बात कर रहे हैं? वहां सेल्फ बैलेंसिंग ट्री हैं। उनके एल्गोरिदम की जांच करें जहां वे निर्धारित करते हैं कि क्या संतुलन बनाए रखने के लिए उन्हें पेड़ को फिर से व्यवस्थित करने की आवश्यकता है।


1

यहां जेनेरिक डेप्थ-फर्स्ट ट्रैवर्सल पर आधारित संस्करण है। अन्य सही उत्तर की तुलना में तेज़ होना चाहिए और सभी उल्लेखित "चुनौतियों" को संभालना चाहिए। शैली के लिए क्षमा याचना, मैं वास्तव में जावा नहीं जानता।

यदि आप अधिकतम और न्यूनतम दोनों सेट हैं और एक अंतर> 1 है, तो आप जल्दी लौटकर इसे बहुत तेज़ बना सकते हैं।

public boolean isBalanced( Node root ) {
    int curDepth = 0, maxLeaf = 0, minLeaf = INT_MAX;
    if ( root == null ) return true;
    while ( root != null ) {
        if ( root.left == null || root.right == null ) {
            maxLeaf = max( maxLeaf, curDepth );
            minLeaf = min( minLeaf, curDepth );
        }
        if ( root.left != null ) {
            curDepth += 1;
            root = root.left;
        } else {
            Node last = root;
            while ( root != null
             && ( root.right == null || root.right == last ) ) {
                curDepth -= 1;
                last = root;
                root = root.parent;
            }
            if ( root != null ) {
                curDepth += 1;
                root = root.right;
            }
        }
    }
    return ( maxLeaf - minLeaf <= 1 );
}

1
एक अच्छा प्रयास लेकिन यह स्पष्ट रूप से काम नहीं करता है। आज्ञा देना x एक शून्य नोड है। एक गैर-शून्य ट्री नोड को (LEFT VALUE RIGHT) के रूप में निरूपित किया जाए। पेड़ पर विचार करें (एक्स ए (एक्स बी एक्स))। "रूट" अंक ए, बी, ए, बी, ए, बी ... हमेशा के लिए। फिर से कोशिश करने की परवाह है? एक संकेत: यह वास्तव में पैरेंट पॉइंटर्स के बिना आसान है ।
एरिक लिपर्ट

@ ईरिक: उफ़, फिक्स्ड (मुझे लगता है)। ठीक है, मैं O (गहराई) मेमोरी के बिना ऐसा करने की कोशिश कर रहा हूं, और अगर संरचना में पैरेंट पॉइंटर्स नहीं हैं (यह अक्सर होता है), तो आपको स्टैक का उपयोग करने की आवश्यकता है।
पोटेटोवाटर

तो आप जो मुझे बता रहे हैं, आप O (d) अस्थायी मेमोरी, जहाँ n <= d <= n लॉग इन करने से बचने के लिए पेरेंट पॉइंटर्स में O (n) स्थायी मेमोरी का उपयोग करेंगे? यह एक झूठी अर्थव्यवस्था की तरह लगता है।
एरिक लिपर्ट

दुर्भाग्य से, यद्यपि आपने समस्या को समस्या के साथ ठीक कर लिया है, फिर भी यहाँ बहुत बड़ी समस्या है। यह परीक्षण नहीं करता है कि क्या एक पेड़ संतुलित है, यह परीक्षण करता है कि क्या एक पेड़ के सभी पत्ते समान स्तर के करीब हैं। यह "संतुलित" की परिभाषा नहीं है जो मैंने दिया था। पेड़ पर विचार करें ((((x D x) C x) B x) A x)। आपका कोड बताता है कि यह "संतुलित" है जब यह स्पष्ट रूप से अधिकतम असंतुलित है। फिर से कोशिश करने की परवाह है?
एरिक लिपर्ट

यदि आप पहले से ही किसी और चीज के लिए पेरेंट पॉइंटर्स का उपयोग करते हैं तो @ एरिक उत्तर 1: झूठी अर्थव्यवस्था नहीं है। उत्तर 2: निश्चित, क्यों नहीं। यह डिबगिंग का एक विचित्र तरीका है ... मुझे सुबह 4 बजे आँख बंद करके कुछ भी नहीं लिखा जाना चाहिए ...
Potatoswatter

1
/* Returns true if Tree is balanced, i.e. if the difference between the longest path and the shortest path from the root to a leaf node is no more than than 1. This difference can be changed to any arbitrary positive number. */
boolean isBalanced(Node root) {
    if (longestPath(root) - shortestPath(root) > 1)
        return false;
    else
        return true;
}


int longestPath(Node root) {
    if (root == null);
        return 0;
    else {
        int leftPathLength = longestPath(root.left);
        int rightPathLength = longestPath(root.right);
        if (leftPathLength >= rightPathLength)
            return leftPathLength + 1;
        else
            return rightPathLength + 1;
    }
}

int shortestPath(Node root) {
    if (root == null);
        return 0;
    else {
        int leftPathLength = shortestPath(root.left);
        int rightPathLength = shortestPath(root.right);
        if (leftPathLength <= rightPathLength)
            return leftPathLength + 1;
        else
            return rightPathLength + 1;
    }
}

1
आपको अपने कोड नमूने में अपने उत्तर और / या टिप्पणियों में कुछ विवरण जोड़ना चाहिए।
ब्रैड कैंपबेल

1
class Node {
    int data;
    Node left;
    Node right;

    // assign variable with constructor
    public Node(int data) {
        this.data = data;
    }
}

public class BinaryTree {

    Node root;

    // get max depth
    public static int maxDepth(Node node) {
        if (node == null)
            return 0;

        return 1 + Math.max(maxDepth(node.left), maxDepth(node.right));
    }

    // get min depth
    public static int minDepth(Node node) {
        if (node == null)
            return 0;

        return 1 + Math.min(minDepth(node.left), minDepth(node.right));
    }

    // return max-min<=1 to check if tree balanced
    public boolean isBalanced(Node node) {

        if (Math.abs(maxDepth(node) - minDepth(node)) <= 1)
            return true;

        return false;
    }

    public static void main(String... strings) {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);


        if (tree.isBalanced(tree.root))
            System.out.println("Tree is balanced");
        else
            System.out.println("Tree is not balanced");
    }
}

0

यहां मैंने एरिक के बोनस अभ्यास के लिए कोशिश की है। मैं अपने पुनरावर्ती छोरों को कम करने की कोशिश करता हूं और जैसे ही मुझे एक संतुलित होने के लिए सबट्री मिल जाती है, वापस आ जाता है।

int heightBalanced(node *root){
    int i = 1;
    heightBalancedRecursive(root, &i);
    return i; 
} 

int heightBalancedRecursive(node *root, int *i){

    int lb = 0, rb = 0;

    if(!root || ! *i)  // if node is null or a subtree is not height balanced
           return 0;  

    lb = heightBalancedRecursive(root -> left,i);

    if (!*i)         // subtree is not balanced. Skip traversing the tree anymore
        return 0;

    rb = heightBalancedRecursive(root -> right,i)

    if (abs(lb - rb) > 1)  // not balanced. Make i zero.
        *i = 0;

    return ( lb > rb ? lb +1 : rb + 1); // return the current height of the subtree
}

0
public int height(Node node){
    if(node==null)return 0;
    else{
        int l=height(node.leftChild);
        int r=height(node.rightChild);
       return(l>r?l+1:r+1);

}}
public boolean balanced(Node n){

    int l= height(n.leftChild);
    int r= height(n.rightChild);

    System.out.println(l + " " +r);
    if(Math.abs(l-r)>1)
        return false;
    else 
        return true;
    }

0

एक खाली पेड़ ऊंचाई-संतुलित है। एक गैर-बाइनरी ट्री टी संतुलित है यदि:

1) T का लेफ्ट सबट्री संतुलित है

2) T का राइट सबट्री संतुलित है

3) बाएं सबट्री और राइट सबट्री की ऊंचाइयों के बीच का अंतर 1 से अधिक नहीं है।

/* program to check if a tree is height-balanced or not */
#include<stdio.h>
#include<stdlib.h>
#define bool int

/* A binary tree node has data, pointer to left child
   and a pointer to right child */
struct node
{
  int data;
  struct node* left;
  struct node* right;
};

/* The function returns true if root is balanced else false
   The second parameter is to store the height of tree.  
   Initially, we need to pass a pointer to a location with value 
   as 0. We can also write a wrapper over this function */
bool isBalanced(struct node *root, int* height)
{
  /* lh --> Height of left subtree 
     rh --> Height of right subtree */   
  int lh = 0, rh = 0;  

  /* l will be true if left subtree is balanced 
    and r will be true if right subtree is balanced */
  int l = 0, r = 0;

  if(root == NULL)
  {
    *height = 0;
     return 1;
  }

  /* Get the heights of left and right subtrees in lh and rh 
    And store the returned values in l and r */   
  l = isBalanced(root->left, &lh);
  r = isBalanced(root->right,&rh);

  /* Height of current node is max of heights of left and 
     right subtrees plus 1*/   
  *height = (lh > rh? lh: rh) + 1;

  /* If difference between heights of left and right 
     subtrees is more than 2 then this node is not balanced
     so return 0 */
  if((lh - rh >= 2) || (rh - lh >= 2))
    return 0;

  /* If this node is balanced and left and right subtrees 
    are balanced then return true */
  else return l&&r;
}


/* UTILITY FUNCTIONS TO TEST isBalanced() FUNCTION */

/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data)
{
    struct node* node = (struct node*)
                                malloc(sizeof(struct node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;

    return(node);
}

int main()
{
  int height = 0;

  /* Constructed binary tree is
             1
           /   \
         2      3
       /  \    /
     4     5  6
    /
   7
  */   
  struct node *root = newNode(1);  
  root->left = newNode(2);
  root->right = newNode(3);
  root->left->left = newNode(4);
  root->left->right = newNode(5);
  root->right->left = newNode(6);
  root->left->left->left = newNode(7);

  if(isBalanced(root, &height))
    printf("Tree is balanced");
  else
    printf("Tree is not balanced");    

  getchar();
  return 0;
}

समय जटिलता: O (n)


0

विशेष रूप से विशाल पेड़ों पर बेहतर प्रदर्शन करने के लिए आप प्रत्येक नोड में ऊँचाई को बचा सकते हैं इसलिए यह अंतरिक्ष बनाम प्रदर्शन का व्यापार है:

class Node {
    Node left;
    Node right;
    int value;
    int height;
}

विलोपन के लिए जोड़ और समान लागू करने का उदाहरण

void addNode(Node root,int v)
{    int height =0;
     while(root != null)
     {
         // Since we are adding new node so the height 
         // will increase by one in each node we will pass by
         root.height += 1;
         height++;
         else if(v > root.value){
            root = root.left();
            }
         else{
         root = root.right();
         }

     }

         height++;
         Node n = new Node(v , height);
         root = n;         
}
int treeMaxHeight(Node root)
{
 return Math.Max(root.left.height,root.right.height);
}

int treeMinHeight(Node root)
{
 return Math.Min(root.left.height,root.right.height);

}

Boolean isNodeBlanced(Node root)
{
   if (treeMaxHeight(root) - treeMinHeight(root) > 2)
       return false;

  return true;
}

Boolean isTreeBlanced (Node root)
{
    if(root == null || isTreeBalanced(root.left) && isTreeBalanced(root.right) && isNodeBlanced(root))
    return true;

  return false;

}

-1
    static boolean isBalanced(Node root) {
    //check in the depth of left and right subtree
    int diff = depth(root.getLeft()) - depth(root.getRight());
    if (diff < 0) {
        diff = diff * -1;
    }
    if (diff > 1) {
        return false;
    }
    //go to child nodes
    else {
        if (root.getLeft() == null && root.getRight() == null) {
            return true;
        } else if (root.getLeft() == null) {
            if (depth(root.getRight()) > 1) {
                return false;
            } else {
                return true;
            }
        } else if (root.getRight() == null) {
            if (depth(root.getLeft()) > 1) {
                return false;
            } else {
                return true;
            }
        } else if (root.getLeft() != null && root.getRight() != null && isBalanced(root.getLeft()) && isBalanced(root.getRight())) {
            return true;
        } else {
            return false;
        }
    }
}

-2

क्या यह काम नहीं करेगा?

return ( ( Math.abs( size( root.left ) - size( root.right ) ) < 2 );

कोई भी असंतुलित पेड़ हमेशा यह विफल रहेगा।


4
कई संतुलित पेड़ इसे भी विफल कर देंगे।
ब्रायन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.