דנאָ מיינונג פון אַ ביינערי בוים  


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

פּראָבלעם סטאַטעמענט  

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

בייַשפּיל  

דנאָ מיינונג פון אַ ביינערי בויםשפּילקע

5 6 4 7

צוגאַנג  

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

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

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

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

C ++ קאָד צו דרוקן די דנאָ פון אַ ביינערי בוים  

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

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

node* create(int data){
    node* tmp = new node();
    tmp->data = data;
    tmp->left = tmp->right = NULL;
    return tmp;
}

int main(){
    node *root = create(2);
    root->left = create(3);
    root->right = create(7);
    root->left->left = create(5);
    root->left->right = create(4);
    root->left->right->left = create(6);

    map<int,int> m;
    queue<pair<int,node*>> q;
    q.push(make_pair(0, root));
    m[0] = root->data;
    while(!q.empty()){
        pair<int, node*> now = q.front();
        q.pop();

        m[now.first] = now.second->data;
        if(now.second->left)
        q.push(make_pair(now.first - 1, now.second->left));
        if(now.second->right)
        q.push(make_pair(now.first + 1, now.second->right));
    }
    for(auto x: m)
        cout<<x.second<<" ";
}
5 6 4 7

דזשאַוואַ קאָד צו דרוקן די ונטער מיינונג פון אַ ביינערי בוים  

import java.util.*;

class node{
  int data;
  node left, right;
  int hd;
}

class Main{

  static node create(int data){
      node tmp = new node();
      tmp.data = data;
      tmp.left = tmp.right = null;
      tmp.hd = 0;
      return tmp;
  }

  public static void main(String[] args){
    node root = create(2);
      root.left = create(3);
      root.right = create(7);
      root.left.left = create(5);
      root.left.right = create(4);
      root.left.right.left = create(6);

      Map<Integer, Integer> m = new TreeMap<Integer, Integer>();
      Queue<node> q = new LinkedList<node>();
      q.add(root);
      m.put(root.hd, root.data);
      while(!q.isEmpty()){
          node now = q.remove();

          m.put(now.hd, now.data);
          if(now.left != null){
          	now.left.hd = now.hd - 1;
          	q.add(now.left);
          }
          if(now.right != null){
          	now.right.hd = now.hd + 1;
          	q.add(now.right);
          }
      }
      for(Map.Entry<Integer, Integer> entry : m.entrySet())
          System.out.print(entry.getValue()+" ");
  }
}
5 6 4 7

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

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

אָ (NlogN), ווייַל מיר האָבן דורכגעקאָכט דעם בוים און האָבן דערהייַנטיקט די וואַלועס. ווייַל מיר האָבן געוויינט אַ מאַפּע, ינסערשאַן, דילישאַן און זוכן איז געשען אין די O (logN) צייט.

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

אָ (N), בייַ רובֿ, עס קען זיין (N + 1) / 2 אין די לעצטע מדרגה. אזוי די פּלאַץ קאַמפּלעקסיטי איז לינעאַר.