גער סאָרטעד אַררייַ צו ביינערי זוכן בוים לעעטקאָדע סאַלושאַן


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַדאָובי אַירבנב אַמאַזאָן עפּל בלומבערג סיסקאָ גוגל מייקראָסאָפֿט אָראַקל ספּאָטיפי וומוואַרע יאַהאָאָ
ביינערי זוכן בוים דעפּט ערשטער זוך

באַטראַכטן אַז מיר זענען סאָרטירט מענגע פון ינטאַדזשערז. דער ציל איז צו בויען אַ ביינערי זוכן בוים פֿון דעם מענגע אַזוי אַז דער בוים איז הייך-באַלאַנסט. באַמערקונג אַז דער בוים איז כיידאַד-באַלאַנסט אויב די הייך פון די לינקס און רעכט סאַבסטריישאַנז פון קיין נאָדע אין דער בוים זענען העכסט 1.

עס איז גרינג צו געפֿינען אַז עס קענען זיין קייפל סאַלושאַנז. מיר דאַרפֿן צו געפֿינען קיין גילטיק לייזונג. באַמערקונג אַז אין דעם פּראָבלעם, מיר טאָן ניט דאַרפֿן צו דרוקן דעם בוים אָבער צו שאַפֿן אַ בוים. מיר נאָר דאַרפֿן צו דרוקן די פאָראָרדער דורך.

בייַשפּיל

Array = {-4 , 0 , 1 , 2 , 7}
1 -4 0 2 7

דערקלערונג: די BST איז:

גער סאָרטעד אַררייַ צו ביינערי זוכן בוים לעעטקאָדע סאַלושאַן

 

Array = {1 , 2 , 3}
2 1 3

דערקלערונג: די BST איז:

גער סאָרטעד אַררייַ צו ביינערי זוכן בוים לעעטקאָדע סאַלושאַן

צוגאַנג (רעקורסיאָן)

מיר דאַרפֿן צו האַלטן שפּור פון צוויי טינגז:

  1. קיין נאָדע זאָל האָבן קלענערער עלעמענטן ווי לינקס קינדער און וויצע ווערסאַ פֿאַר רעכט קינדער
  2. די BST זאָל זיין הייך באַלאַנסט

צו האַלטן דעם בוים אין קיין מאָמענט באַלאַנסט, מיר מוזן קלייַבן אַ מיטל עלעמענט פון דער מענגע ווי דער וואָרצל. אין דעם וועג, מיר וועלן האָבן אַ הייך חילוק פון 1 צווישן די לינקס און רעכט סאַבסטריישאַנז אויב די מענגע איז גלייך גרייס און אַ הייך חילוק פון ווען די מענגע איז פון אַ שאַנסן.

איצט, ווען מיר סעלעקטירן קיין מיטל נאָדע ווי וואָרצל, מיר מוזן מאַכן די לינקס סובטרע פֿון די לינקס סובאַרע און די רעכט סובטרע פֿון די רעכט סובאַריי. דאָס איז אַ סאַב-פּראָבלעם פון אונדזער אָריגינעל פּראָבלעם און מיר קענען סאָלווע עס רעקורסיוועלי. נאָך באַשטימען די לינק און רעכט סאַבסטרי צו די מיטל נאָדע, מיר קענען צוריקקומען עס און דרוקן די פּאָסטאָרדער דורך די ביינערי זוכן בוים.

אַלגאָריטהם

  1. שאַפֿן אן אנדער פונקציע converArrayToBST () וואָס וועט בייַטן קיין באַזונדער קייט פון געגעבן מענגע און צוריקקומען זיין קאָראַספּאַנדינג BST שורש נאָדע.
  2. זאל L = לינקס שיעור פון מענגע און R = רעכט שיעור פון מענגע אין די אויבן-דערמאנט קייט.
    1. אויב ל> ר
      • צוריקקומען נאַל, ווייַל מיר באַקומען אַ פאַלש קייט
    2. אויב ל == ר
      • צוריקקומען אַ נייַ נאָדע מיט די זעלבע ווערט ווי אַרײַע [L] 
    3. געפֿינען די מיטל נאָדע פון ​​דעם קייט ווי מיטן = (ל + (ר - ל) / 2)
      • ערשט ערשט ווי אַ נייַ BST נאָדע מיט די זעלבע ווערט ווי אַרײַע [מיטן]
      • באַשטימען לינקס און רעכט סובטרעעס ווי די זעלבע פֿונקציע גערופֿן אויף ריספּעקטיוולי לינקס און רעכט סאַב-ריינדזשאַז
      • צוריקקומען קאָפּ
  3. דרוק דעם פּריאָרדער דורך די ביינערי זוכן בוים

ימפּלאַמענטיישאַן פון קאָנווערט סאָרטעד עריי צו ביינערי זוכן בוים לעעטקאָדע סאַלושאַן

C + + לייזונג צו קאָנווערט סאָרטעד עריי צו ביינערי זוכן בוים

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

struct BSTNode
{
    int value;
    BSTNode *left , *right;
    BSTNode(int x)
    {
        value = x;
        left = NULL;
        right = NULL;
    }
};

BSTNode* convertArrayToBST(vector <int> &a , int l , int r)
{
    if(l > r)
        return NULL;
    if(l == r)
        return new BSTNode(a[l]);
    int mid = (l + (r - l) / 2);
    BSTNode* head = new BSTNode(a[mid]);
    head->left = convertArrayToBST(a , l , mid - 1);
    head->right = convertArrayToBST(a , mid + 1 , r);
    return head;
}

BSTNode* sortedArrayToBST(vector<int>& a)
{
    int n = a.size();
    return convertArrayToBST(a , 0 , n - 1);
}

void preorder(BSTNode* head)
{
    if(!head)
        return;
    cout << head->value << " ";
    preorder(head->left);
    preorder(head->right);
}


int main()
{
    vector <int> a = {-4 , 0 , 1 , 2 , 7};
    BSTNode* head = sortedArrayToBST(a);
    preorder(head);
    return 0;
}

Java סאַלושאַן צו קאָנווערט סאָרטעד עריי צו ביינערי זוכן בוים

class BSTNode
{
    int value;
    BSTNode left , right;
    BSTNode(int x)
    {
        value = x;
        left = null;
        right = null;
    }
}

class convert_array_to_BST
{
    public static void main(String args[])
    {
        int[] a = {-4 , 0 , 1 , 2 , 7};
        BSTNode head = sortedArrayToBST(a);
        preorder(head);
    }

    static BSTNode convertArrayToBST(int[] a , int l , int r)
    {
        if(l > r)
            return null;
        if(l == r)
            return new BSTNode(a[l]);
        int mid = (l + (r - l) / 2);
        BSTNode head = new BSTNode(a[mid]);
        head.left = convertArrayToBST(a , l , mid - 1);
        head.right = convertArrayToBST(a , mid + 1 , r);
        return head;
    }

    static BSTNode sortedArrayToBST(int[] a)
    {
        return convertArrayToBST(a , 0 , a.length - 1);
    }

    static void preorder(BSTNode head)
    {
        if(head == null)
            return;
        System.out.print(head.value + " ");
        preorder(head.left);
        preorder(head.right);
    }
}
1 -4 0 2 7

קאַמפּלעקסיטי אַנאַליסיס פון קאָנווערט סאָרטעד עריי צו ביינערי זוכן בוים לעעטקאָדע סאַלושאַן

צייט קאַמפּלעקסיטי

אָ (N), N = נומער פון עלעמענטן אין דער בוים. מיר באַזוכן יעדער עלעמענט צו בויען די BST און צו דרוקן די פּרעאָרדער דורך.

ספעיס קאַמפּלעקסיטי

אוי), ווו ה = הייך פון דעם בוים = logN. אין ביידע די רעקורסיווע פאַנגקשאַנז, מיר מאַכן זיכער אַז דער בוים איז הייך-באַלאַנסט, אַזוי מיר נוצן אַ מאַקסימום פון אוי) פּלאַץ פֿאַר רעקורסיווע אָנלייגן ראָמען.