تحقق مما إذا كانت جميع مستويات الشجرة الثنائية هي الجناس الناقصة أم لا


مستوى الصعوبة الثابت
كثيرا ما يطلب في أدوبي أمازون فيسبوك المتعصبون فوركايتس رمادي
إعادة ترتيب الأحرف شجرة ثنائية طابور شجرة

المشكلة بيان

المشكلة "تحقق مما إذا كانت جميع مستويات الشجرتين الثنائية هي الجناس الناقصة أم لا" تقول أنه تم إعطاؤك شجرتين ثنائيتين ، تحقق مما إذا كانت جميع مستويات الشجرتين عبارة عن جناس ناقص أم لا.

أمثلة

إدخال

تحقق مما إذا كانت جميع مستويات الشجرة الثنائية هي الجناس الناقصة أم لا

true

إدخال

تحقق مما إذا كانت جميع مستويات الشجرة الثنائية هي الجناس الناقصة أم لا

false

خوارزمية للتحقق مما إذا كانت جميع مستويات الشجرة الثنائية هي الجناس الناقصة أم لا

سوف نستخدم الثرم لحل هذه المشكلة. اجتياز كل مستوى من اثنين الأشجار الوقت ذاته. بالنسبة للشجرة الأولى ، قم بتخزين العنصر وتكرار المستوى الحالي في ملف خريطة التجزئة وبالنسبة للمستوى الحالي للشجرة الثانية ، إذا كان العنصر الحالي غير موجود في HashMap. جميع المستويات ليست الجناس الناقصة. عدا ذلك ، قلل من تكرار هذا العنصر في HashMap. إذا كانت HashMap فارغة في نهاية الاجتياز ، فإن هذا المستوى من كلتا الشجرتين هو الجناس الناقص متابعة للمستويات التالية ، وإلا فإن جميع المستويات ليست كذلك الجناس.

  1. قم بإنشاء اثنين طوابير q1 و q2 ، q1 يستخدم لاجتياز الشجرة 1 ويستخدم q2 لاجتياز q2.
  2. ادفع جذر الشجرة من 1 إلى q1 وجذر الشجرة 2 حتى q2.
  3. بينما إما أن q1 ليس فارغًا أو q2 ليس فارغًا ، كرر الخطوات 4 و 5 و 6.
  4. قم بإنشاء HashMap لتخزين العناصر وتكرار عناصر المستوى الحالي. تهيئة حجم عدد صحيح 1 كحجم q1. قم بتشغيل حلقة من 0 إلى أقل من size1. في كل تكرار ، يتم إخراج عنصر من قائمة الانتظار q1 وإضافته إلى HashMap. ادفع أبناء العنصر الحالي إلى ملف طابور.
  5. تهيئة حجم عدد صحيح 2 بحجم q2. قم بتشغيل حلقة من 0 إلى أقل من size2. في كل تكرار ، أخرج عنصرًا من قائمة الانتظار q2 وإذا كان هذا العنصر موجودًا في HashMap قلل تكراره بمقدار 1 ، وإلا فقم بإرجاع خطأ على الفور.
  6. إذا كان HashMap في نهاية الحلقة يحتوي على عنصر ، فقم بإرجاع القيمة false ، وإلا فإن هذا المستوى من الشجرتين عبارة عن الجناس الناقصة ، فتابع إلى المستوى التالي.
  7. إذا وصلنا إلى هنا ، فإن جميع مستويات الشجرتين هي الجناس الناقصة ، لذا عد صحيحًا.

رمز

كود Java للتحقق مما إذا كانت جميع مستويات اثنين من Binary Tree هي الجناس الناقصة أم لا

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;

class CheckIfAllLevelsOfTwoBinaryTreeAreAnagramsOrNot {
    // class representing node of a binary tree
    static class Node {
        int data;
        Node left, right;

        public Node(int data) {
            this.data = data;
        }
    }

    private static boolean checkIsAnagrams(Node tree1, Node tree2) {
        // create two queues
        Queue<Node> q1 = new LinkedList<>();
        Queue<Node> q2 = new LinkedList<>();
        // add root of tree1 to q1
        q1.add(tree1);
        // add root of tree2 to q2
        q2.add(tree2);

        // while either of q1 or q2 is not empty
        while (!q1.isEmpty() || !q2.isEmpty()) {
            // create a hash map to store freq of elements of a level
            HashMap<Integer, Integer> freq = new HashMap<>();

            // traverse this level of tree1
            int size1 = q1.size();
            for (int i = 0; i < size1; i++) {
                // remove a node from queue
                Node curr = q1.poll();
                // add the element to hash map
                if (freq.containsKey(curr.data)) {
                    freq.put(curr.data, freq.get(curr.data) + 1);
                } else {
                    freq.put(curr.data, 1);
                }

                // add curr's children to queue
                if (curr.left != null)
                    q1.add(curr.left);
                if (curr.right != null)
                    q1.add(curr.right);
            }

            // traverse this level of tree2
            int size2 = q2.size();
            for (int i = 0; i < size2; i++) {
                // remove a node from q2
                Node curr = q2.poll();
                // decrease the frequency of this element in hash map
                if (freq.containsKey(curr.data)) {
                    int frequency = freq.get(curr.data);
                    frequency--;
                    if (frequency == 0) {
                        freq.remove(curr.data);
                    } else {
                        freq.put(curr.data, frequency);
                    }
                } else {
                    return false;
                }

                // add curr's children to queue
                if (curr.left != null)
                    q2.add(curr.left);
                if (curr.right != null)
                    q2.add(curr.right);
            }

            // if there is an element in the hash map
            // the two tree's current levels are not anagrams
            if (freq.size() > 0) {
                return false;
            }
        }

        // all the levels are anagrams, return true
        return true;
    }

    public static void main(String[] args) {
        // Example 1
        Node tree1_1 = new Node(5);
        tree1_1.left = new Node(4);
        tree1_1.right = new Node(3);
        tree1_1.left.left = new Node(2);
        tree1_1.left.right = new Node(1);

        Node tree2_1 = new Node(5);
        tree2_1.left = new Node(3);
        tree2_1.right = new Node(4);
        tree2_1.left.left = new Node(1);
        tree2_1.right.left = new Node(2);

        System.out.println(checkIsAnagrams(tree1_1, tree2_1));

        // Example 2
        Node tree1_2 = new Node(5);
        tree1_2.left = new Node(7);
        tree1_2.right = new Node(8);
        tree1_2.left.left = new Node(9);

        Node tree2_2 = new Node(5);
        tree2_2.left = new Node(7);
        tree2_2.right = new Node(8);
        tree2_2.left.left = new Node(1);
        tree2_2.right.left = new Node(2);

        System.out.println(checkIsAnagrams(tree1_2, tree2_2));
    }
}
true
false

كود C ++ للتحقق مما إذا كانت جميع مستويات الشجرة الثنائية هي الجناس الناقصة أم لا

#include<bits/stdc++.h> 
using namespace std; 

// class representing node of a binary tree
class Node {
    public:
    int data;
    Node *left;
    Node *right;
    
    Node(int d) {
        data = d;
        left = right = NULL;
    }
};

// function to create a new node with given data
Node* newNode(int data) {
    Node *node = new Node(data);
    return node;
}

bool checkIsAnagrams(Node *tree1, Node *tree2) {
    // create two queues
    queue<Node *> q1;
    queue<Node *> q2;
    // add root of tree1 to q1
    q1.push(tree1);
    // add root of tree2 to q2
    q2.push(tree2);
    
    // while either of q1 or q2 is not empty
    while (!q1.empty() || !q2.empty()) {
        // create a hash map to store freq of elements of a level
        unordered_map<int, int> freq;
        
        // traverse this level of tree1
        int size1 = q1.size();
        for (int i = 0; i < size1; i++) {
            // remove a node from queue
            Node *curr = q1.front();
            q1.pop();
            
            // add the element to hash map
            auto itr = freq.find(curr->data);
            if (itr != freq.end()) {
                itr->second++;
            } else {
                freq.insert(make_pair(curr->data, 1));
            }
            
            // add curr's children to queue
            if (curr->left != NULL)
                q1.push(curr->left);
            if (curr->right != NULL)
                q1.push(curr->right);
        }
        
        // traverse this level of tree2
        int size2 = q2.size();
        for (int i = 0; i < size2; i++) {
            // remove a node from q2
            Node *curr = q2.front();
            q2.pop();
    
            // decrease the frequency of this element in hash map
            auto itr = freq.find(curr->data);
            if (itr != freq.end()) {
                itr->second--;
                if (itr->second == 0) {
                    freq.erase(itr);
                }
            } else {
                return false;
            }
            
            // add curr's children to queue
            if (curr->left != NULL)
                q2.push(curr->left);
            if (curr->right != NULL)
                q2.push(curr->right);
        }
        
        // if there is an element in the hash map
        // the two tree's current levels are not anagrams
        if (freq.size() != 0)
            return false;
    }
    
    // all the levels are anagrams, return true
    return true;
}

int main() {
    // Example 1
    Node *tree1_1 = newNode(5);
    tree1_1->left = newNode(4);
    tree1_1->right = newNode(3);
    tree1_1->left->left = newNode(2);
    tree1_1->left->right = newNode(1);

    Node *tree2_1 = new Node(5);
    tree2_1->left = newNode(3);
    tree2_1->right = newNode(4);
    tree2_1->left->left = newNode(1);
    tree2_1->right->left = newNode(2);

    if (checkIsAnagrams(tree1_1, tree2_1)) {
        cout<<"true"<<endl;
    } else {
        cout<<"false"<<endl;
    }

    // Example 2
    Node *tree1_2 = newNode(5);
    tree1_2->left = newNode(7);
    tree1_2->right = newNode(8);
    tree1_2->left->left = newNode(9);

    Node *tree2_2 = newNode(5);
    tree2_2->left = newNode(7);
    tree2_2->right = newNode(8);
    tree2_2->left->left = newNode(1);
    tree2_2->right->left = newNode(2);

    if (checkIsAnagrams(tree1_2, tree2_2)) {
        cout<<"true"<<endl;
    } else {
        cout<<"false"<<endl;
    }   
    
    return 0;
}
true
false

تحليل التعقيد

نظرًا لأننا اجتازنا كلا الشجرتين مرة واحدة تمامًا واستخدمنا قائمتين من قوائم الانتظار لمسح ترتيب المستوى ، لذلك

تعقيد الوقت = يا (ن + م)
تعقيد الفضاء = يا (ن + م)
حيث n هو عدد العقد في الشجرة 1 و m هو عدد العقد في الشجرة 2.