קטה אָוועס פון אַ נאָדע אין ביינערי בוים


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

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

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

בייַשפּיל

קטה אָוועס פון אַ נאָדע אין ביינערי בוים

2nd ancestor of 4 is 7

צוגאַנג

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

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

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

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

קאָדעקס

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;
}

node* tmp = NULL;

node* kthAncestor(node *root, int cur, int &k)
{
  if (root == NULL)
    return NULL;
  if (root->data == cur || (tmp = kthAncestor(root->left,cur,k)) || (tmp = kthAncestor(root->right,cur,k))){
    if(k)k--;
    else if (k == 0){
      cout<<"kth ancestor of "<<cur<<" is "<<root->data;
      return NULL;
    }
    return root;
  }
}

int main()
{
  node* root = create(5);
  root->left = create(7);
  root->right = create(3);
  root->left->left = create(9);
  root->left->right = create(6);
  root->left->right->left = create(1);
  root->left->right->right = create(4);
  int k = 2;
  kthAncestor(root, 4, k);
}
kth ancestor of 4 is 7

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

import java.util.*;
class node{
  int data;
  node left, right;
}
class Main{

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

  	static int k = 2;
  static node tmp = null;

  static node kthAncestor(node root, int cur)
  {
    if (root == null)
      return null;
    if ((root.data == cur) || ((tmp = kthAncestor(root.left,cur)) != null) || ((tmp = kthAncestor(root.right,cur)) != null)){
      if(k > 0)k--;
      else if (k == 0){
        System.out.print("kth ancestor of "+cur+" is "+root.data);
        return null;
      }
      return root;
    }
    return null;
  }

  public static void main(String[] args)
  {
    node root = create(5);
    root.left = create(7);
    root.right = create(3);
    root.left.left = create(9);
    root.left.right = create(6);
    root.left.right.left = create(1);
    root.left.right.right = create(4);
    k = 2;
    kthAncestor(root, 4);
  }
}
kth ancestor of 4 is 7

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

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

אָ (N)ווייַל אין די ערגסט פאַל מיר האָבן צו פאָרן אַלע די נאָודז איידער וואָס מיר געפֿינען די פארלאנגט נאָדע.

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

אָ (N)ווייַל פון די קאַמפּיילער סטאַק וואָס איז געניצט פֿאַר די רעקורסיווע פאַנגקשאַנז.