အနိမ့်ဆုံးအဖြစ်များသည့်ဘိုးဘေး


ခက်ခဲအဆင့် အလယ်အလတ်
မကြာခဏမေးတယ် Adobe က အမေဇုံ Apple ဘလွန်းဘာ့ဂ် Facebook က Google LinkedIn တို့ Microsoft က Oracle က Pony.ai Zillow
သစ်ပင်

တစ် ဦး binary ၏အမြစ်ပေးထားသည် သစ်ပင် နှင့် node နှစ်ခု n1 နှင့် n2 သည် node များ၏ LCA (အနိမ့်ဆုံးအဖြစ်များသည့်ဘိုးဘေး) ကိုရှာပါ။

နမူနာ

အနိမ့်ဆုံးအဖြစ်များသည့်ဘိုးဘေး

အနိမ့်ဆုံးအဖြစ်များသည့်ဘိုးဘေး (LCA) ဆိုသည်မှာအဘယ်နည်း။

node တစ်ခု၏ဘိုးဘေးများသည် root နှင့် node အကြားလမ်းကြောင်းရှိပစ္စုပ္ပန် node များဖြစ်သည်။ အပေါ်ကဥပမာမှာပြထားတဲ့ binary tree ကိုစဉ်းစားပါ။
ဘိုးဘေး ၆၀ သည် ၁၀၊ ၃၀၊ ၄၀ နှင့် ၆၀ ဖြစ်သည်
ဘိုးဘေး ၅၀ သည် ၁၀၊ ၃၀ နှင့် ၅၀ တို့ဖြစ်ကြသည်
n1 နှင့် n2 ၏အနိမ့်ဆုံးဘုံဘိုးဘေးသည် ninary နှစ်ခု၏အနိမ့်ဆုံး (binary tree) သည်ဘုံဘိုးဘေးသို့မဟုတ် node နှစ်ခု၏နောက်ဆုံးဘုံဘိုးဘေးဖြစ်သည်။ ဆိုလိုသည်မှာ ၅၀ နှင့် ၆၀ အတွက် LCA သည်အသက် ၃၀ ဖြစ်သည်။

အနိမ့်ဆုံးအဖြစ်များသောဘိုးဘွားများအတွက်နုံချဉ်းကပ်နည်း

n1 နှင့် n2 ၏ LCA ကိုတွေ့နိုင်သည်။

  1. အမြစ်မှ n1 သို့လမ်းကြောင်းကိုရှာဖွေခြင်းနှင့်သိမ်းဆည်းခြင်း။
  2. Root မှ n2 လမ်းကြောင်းကိုအခြား array path2 တွင်ရှာဖွေပြီးသိမ်းဆည်းပါ။
  3. အကယ်၍ root မှ n1 သို့ root (n1 မရှိ) (သို့) root မှ n2 (root n2 မရှိ) သည် null သို့ပြန်သွားပါ။
  4. အခြားလမ်းကြောင်းနှစ်ခုကိုနှိုင်းယှဉ်ကြည့်ပါက LCA သည်လမ်းကြောင်းများရှိနောက်ဆုံးဘုံဆုံမှတ်ဖြစ်သည်။

Path Algorithm ကိုရှာပါ

အကယ်၍ root မှပေးထားသော node သို့လမ်းကြောင်းတစ်ခုတည်ရှိပါက၎င်းလမ်းကြောင်းကို array ထဲသိမ်းဆည်းပြီး true return return false သို့ပြန်သွားပါ။

  1. အကယ်၍ root သည် null ဖြစ်လျှင် return ပြန်ပေးပါ။
  2. လက်ရှိ node သည်လိုအပ်သော node သို့ပြန်သွားပါက path array ထဲရှိ current node ကိုထည့်ပါ။
  3. ဘယ်ဘက်နှင့်ညာဘက် subtree အတွက် findPath function ကိုပြန်လည်ခေါ်ယူခြင်းဖြင့်လမ်းကြောင်းနှင့်လမ်းကြောင်းကိုစစ်ဆေးပါ။
  4. လက်ဝဲသို့မဟုတ်လက်ျာ subtree ၌လမ်းကြောင်းတစ်ခုရှိပါက true ပြန်ပို့ပါ။
  5. အခြားသည်လမ်းကြောင်းခင်းကျင်းမှုမှလက်ရှိ node ကိုဖယ်ရှားပြီး false ကိုပြန်ပို့ပါ။

အနိမ့်ဆုံးအဖြစ်များသည့်ဘိုးဘေးများအတွက် JAVA Code ကို

import java.util.*;

public class BinaryTreeLCA {
    // class to represent node of a binary tree
    static class Node {
        int data;
        Node left, right;

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

    private static Node LCA(Node root, int n1, int n2) {
        // Stores path from root to n1
        ArrayList<Node> path1 = new ArrayList<>();
        // Stores path from root to n2
        ArrayList<Node> path2 = new ArrayList<>();

        if (!findPath(root, n1, path1) || !findPath(root, n2, path2)) {
            // Either n1 or n2 does not exists in the tree
            return null;
        }

        // Compare the two path arrays
        Node LCA = null;
        for (int i = 0; i < path1.size() && i < path2.size(); i++) {
            if (path1.get(i) != path2.get(i)) {
                // First non common node
                break;
            } else {
                LCA = path1.get(i);
            }
        }
        return LCA;
    }

    // Function to find the path from root to given node and store it in an array
    private static boolean findPath(Node root, int n, ArrayList<Node> path) {
        if (root == null) {
            // Return false if root is null
            return false;
        }

        // Add the current root in the path array
        path.add(root);
        // If this node is the required node return true
        if (root.data == n) {
            return true;
        }

        // Find path in the left and right sub tree
        if (findPath(root.left, n, path) || findPath(root.right, n, path)) {
            // If there is a path in either left or right sub tree return true
            return true;
        }
        // Else remove root from path array and return false
        path.remove(root);
        return false;
    }

    public static void main(String[] args) {
        // Construct the tree shown in above example
        Node root = new Node(10);
        root.left = new Node(20);
        root.right = new Node(30);
        root.right.left = new Node(40);
        root.right.right = new Node(50);
        root.right.left.left = new Node(60);
        root.right.right.left = new Node(70);
        root.right.right.right = new Node(80);

        // Queries
        System.out.println(LCA(root, 20, 80).data);
        System.out.println(LCA(root, 80, 30).data);
        System.out.println(LCA(root, 70, 80).data);
    }
}

အနိမ့်ဆုံးအဖြစ်များသည့်ဘိုးဘေးများအတွက် C ++ ကုဒ်

#include <iostream>
#include <vector>
using namespace std;

// Class representing node of binary tree
class Node {
    public:
    int data;
    Node *left;
    Node *right;
};

// Function to allocate new memory to a tree node
Node* newNode(int data) { 
    Node *node = new Node(); 
    node->data = data; 
    node->left = NULL; 
    node->right = NULL;
  
    return (node); 
}

// Function to find the path from root to given node and store it in an array
bool findPath(Node *root, int n, vector<int> &path) {
    if (root == NULL) {
        // Return false if root is null
        return false;
    }
    
    // Add the current root in the path array
    path.push_back(root->data);
    // If this node is the required node return true
    if (root->data == n) {
        return true;
    }
    
    // Find path in the left and right sub tree
    if (findPath(root->left, n, path) || findPath(root->right, n, path)) {
        // If there is a path in either left or right sub tree return true
        return true;
    }
    // Else remove root from path array and return false
    path.pop_back();
    return false;
}

int LCA(Node *root, int n1, int n2) {
    // Stores path from root to n1
    vector<int> path1;
    // Stores path from root to n2
    vector<int> path2;
    
    if (!findPath(root, n1, path1) || !findPath(root, n2, path2)) {
        // Either n1 or n2 does not exists in the tree
        return -1;
    }
    
    // Compare the two path arrays
    int i = 0;
    for (; i < path1.size() && i < path2.size(); i++) {
        if (path1[i] != path2[i]) {
            // First non common node
            break;
        }
    }
    return path1[i - 1];
}

int main() {
  // Construct the tree shown in above example
    Node *root = newNode(10);
    root->left = newNode(20);
    root->right = newNode(30);
    root->right->left = newNode(40);
    root->right->right = newNode(50);
    root->right->left->left = newNode(60);
    root->right->right->left = newNode(70);
    root->right->right->right = newNode(80);
    
    // Queries
    cout<<LCA(root, 20, 80)<<endl;
    cout<<LCA(root, 80, 30)<<endl;
    cout<<LCA(root, 70, 80)<<endl;
    
    return 0;
}
10
30
50

ရှုပ်ထွေးဆန်းစစ်ခြင်း

အချိန်ရှုပ်ထွေး = အို (ဎ)
အထက်ပါဖြေရှင်းချက်လိုအပ်တယ် 3 ဖြတ်သန်း သစ်ပင်သစ်ပင်၏လမ်းကြောင်း၊ လမ်းကြောင်းများဖြည့်ရန်နှစ်ခု၊ ၁ ခုသည်ဤ arrays များကိုနှိုင်းယှဉ်ရန်ဖြစ်သည်။

အနိမ့်ဆုံးအဖြစ်များသည့်ဘိုးဘေးများအတွက်အကောင်းဆုံးနည်းလမ်း

ကျနော်တို့ LCA ကိုရှာဖွေရန်ရှိသည်သောအဘို့ n1 နှင့် n2, သစ်ပင်၌တည်ရှိကြောင်းယူဆလျှင်, အထက်ပါပြproblemနာတစ်ခုတည်းဖြတ်သန်းအတွက်ဖြေရှင်းနိုင်သည်။

သစ်ပင်ကိုဖြတ်လိုက်ပါ။ node တိုင်းအတွက်ကိစ္စလေးခုအနက်တစ်ခုရှိသည်။

  1. လက်ရှိ node သည် n1 (သို့) n2 ဖြစ်စေ၊ ဤကိစ္စတွင်ကျွန်ုပ်တို့သည် node ကိုပြန်ပို့သည်။
  2. လက်ရှိ node ၏ subtrees တစ်ခုတွင် n1 ပါ ၀ င်ပြီးအခြား n2 တွင်ပါ ၀ င်သည်။ ဤ node သည် LCA ဖြစ်ပြီး node ကိုပြန်သွားပါ။
  3. လက်ရှိ node ၏ subtree တစ်ခုတွင် n1 နှင့် n2 နှစ်ခုလုံးပါ ၀ င်သည်။
  4. အဆိုပါ subtrees အဘယ်သူမျှမ n1 နှင့် n2 ပါရှိသည်, return null ။

အနိမ့်ဆုံးအဖြစ်များသည့်ဘိုးဘေးများအတွက် JAVA Code ကို

import java.util.ArrayList;

public class Naive {
    // class to represent node of a binary tree
    static class Node {
        int data;
        Node left, right;

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

    private static Node LCA(Node root, int n1, int n2) {
        // Stores path from root to n1
        ArrayList<Node> path1 = new ArrayList<>();
        // Stores path from root to n2
        ArrayList<Node> path2 = new ArrayList<>();

        if (!findPath(root, n1, path1) || !findPath(root, n2, path2)) {
            // Either n1 or n2 does not exists in the tree
            return null;
        }

        // Compare the two path arrays
        Node LCA = null;
        for (int i = 0; i < path1.size() && i < path2.size(); i++) {
            if (path1.get(i) != path2.get(i)) {
                // First non common node
                break;
            } else {
                LCA = path1.get(i);
            }
        }
        return LCA;
    }

    // Function to find the path from root to given node and store it in an array
    private static boolean findPath(Node root, int n, ArrayList<Node> path) {
        if (root == null) {
            // Return false if root is null
            return false;
        }

        // Add the current root in the path array
        path.add(root);
        // If this node is the required node return true
        if (root.data == n) {
            return true;
        }

        // Find path in the left and right sub tree
        if (findPath(root.left, n, path) || findPath(root.right, n, path)) {
            // If there is a path in either left or right sub tree return true
            return true;
        }
        // Else remove root from path array and return false
        path.remove(root);
        return false;
    }

    public static void main(String[] args) {
        // Construct the tree shown in above example
        Node root = new Node(10);
        root.left = new Node(20);
        root.right = new Node(30);
        root.right.left = new Node(40);
        root.right.right = new Node(50);
        root.right.left.left = new Node(60);
        root.right.right.left = new Node(70);
        root.right.right.right = new Node(80);

            // Queries
        System.out.println(LCA(root, 20, 80).data);
        System.out.println(LCA(root, 80, 30).data);
        System.out.println(LCA(root, 70, 80).data);
    }
}

အနိမ့်ဆုံးအဖြစ်များသည့်ဘိုးဘေးများအတွက် C ++ ကုဒ်

#include <iostream>
#include <vector>
using namespace std;

// Class representing node of binary tree
class Node {
    public:
    int data;
    Node *left;
    Node *right;
};

// Function to allocate new memory to a tree node
Node* newNode(int data) { 
    Node *node = new Node(); 
    node->data = data; 
    node->left = NULL; 
    node->right = NULL;
  
    return (node); 
}

Node* LCA(Node *root, int n1, int n2) {
    // Return null for a null root
    if (root == NULL) {
        return NULL;
    }
    
    // Current node is either n1 or n2
    if (root->data == n1 || root->data == n2) {
        return root;
    }
    
    // Traverse the tree to find the LCA in left and right sub tree
    Node *LCA1 = LCA(root->left, n1, n2);
    Node *LCA2 = LCA(root->right, n1, n2);
    
    // One of the sub tree contains n1 and other contains n2, this is the LCA
    if (LCA1 != NULL && LCA2 != NULL) {
        return root;
    }
    // Left sub tree contains both n1 and n2, return what sub tree returns
    if (LCA1 != NULL) {
        return LCA1;
    }
    // Right sub tree contains both n1 and n2, return what sub tree returns
    if (LCA2 != NULL) {
        return LCA2;
    }
    // None of the sub tree contains n1 and n2
    return NULL;
}

int main() {
  // Construct the tree shown in above example
    Node *root = newNode(10);
    root->left = newNode(20);
    root->right = newNode(30);
    root->right->left = newNode(40);
    root->right->right = newNode(50);
    root->right->left->left = newNode(60);
    root->right->right->left = newNode(70);
    root->right->right->right = newNode(80);
    
    // Queries
    cout<<LCA(root, 20, 80)->data<<endl;
    cout<<LCA(root, 80, 30)->data<<endl;
    cout<<LCA(root, 70, 80)->data<<endl;
    
    return 0;
}
10
30
50

ရှုပ်ထွေးဆန်းစစ်ခြင်း

အချိန်ရှုပ်ထွေး = အို (ဎ) ဘယ်မှာ n ပေးထားသောသစ်ပင်၌ပစ္စုပ္ပန် node များ၏အရေအတွက်သည်။
အထက်ပါဖြေရှင်းချက်တစ်ခုလိုအပ်သည် တစ်ခုတည်းဖြတ်သန်း အဆိုပါ LCA ကိုရှာဖွေရန်။

ကိုးကား