பைனரி மரத்தின் எல்லை பயணம்  


சிரமம் நிலை நடுத்தர
அடிக்கடி கேட்கப்படுகிறது அகோலைட் அமேசான் உயர்வு கிருத்திகல் தீர்வுகள் மைக்ரோசாப்ட் மோர்கன் ஸ்டான்லி PayU Snapdeal
பைனரி மரம் மரம் மரம் பயணம்

சிக்கல் அறிக்கை  

“பைனரி மரத்தின் எல்லைப் பயணம்” என்ற சிக்கல் உங்களுக்கு ஒரு பைனரி மரம் வழங்கப்படுவதாகக் கூறுகிறது. இப்போது நீங்கள் a இன் எல்லைக் காட்சியை அச்சிட வேண்டும் பைனரி மரம். இங்கே எல்லை குறுக்குவெட்டு என்பது அனைத்து முனைகளும் மரத்தின் எல்லையாகக் காட்டப்படுகின்றன. முனைகள் மேல் பக்கத்திலும், இடது பக்கத்திலும், கீழ் பக்கத்திலும், வலது பக்கத்திலும் இருந்து கடிகார திசையில் காணப்படுகின்றன. ஆனால் இந்த காட்சிகள் அனைத்தையும் நாம் நேரடியாக அச்சிட்டிருந்தால், அது ஒரே முனைகளை பல முறை அச்சிடும். எனவே முனைகள் மீண்டும் நிகழாத வகையில் எல்லைக் காட்சியை அச்சிடுங்கள்.

உதாரணமாக  

முள்

2 3 5 6 4 7

விளக்கம்

இங்கே, அனைத்து முனைகளும் எல்லை முனைகளாகும். ஆனால் நாம் கடிகார எதிர்ப்பு திசையில் முனைகளை அச்சிட வேண்டும். இவ்வாறு நாம் 2 என்ற மூலத்திலிருந்து தொடங்குகிறோம். பின்னர், நாம் அதே முறையில் நகர்ந்து 2, 3, 4, 6, 4, 7 முனைகளை அச்சிடுகிறோம்.

பைனரி மரத்தின் எல்லை பயணம்முள்

5 7 9 1 4 3

அணுகுமுறை  

மரத்தின் எல்லையை அச்சிட சிக்கல் கேட்கிறது, இங்கே நாம் இடது, வலது மற்றும் கீழ் எல்லையை வைத்திருக்கிறோம். மரத்தில் இடது அல்லது வலது எல்லை எதுவும் இல்லை என்றால். வேர் இடது அல்லது வலது எல்லையாக கருதப்படுகிறது. எல்லை முனைகளை அச்சிட்டால், இரண்டு முனைகளிலும் எதுவும் பல முறை அச்சிடப்படாமல் இருக்க வேண்டும் என்பதில் ஒரு நிபந்தனையும் உள்ளது.

மேலும் காண்க
பைனரி மரத்தில் அதிகபட்ச நிலை தொகையைக் கண்டறியவும்

சிக்கலைத் தீர்க்க, மரத்தின் இடது எல்லையுடன் தொடங்குவோம். அந்த முனை இடது பக்கத்திலிருந்து தெரிந்தால் ஒரு முனை இடது எல்லைக்கு சொந்தமானது என்று நாங்கள் கூறுகிறோம். இதேபோல், வலது பக்க முனைகள் மற்றும் இலை முனைகளை வரையறுக்கிறோம். இடது எல்லையை அச்சிடுவதற்கு, மரத்தை ஒரு இடது முனை இருந்தால், அதன் வலது முனைக்கு நகரும் வகையில் மரத்தை கடந்து செல்வோம். ஒருமுறை நாம் இலை முனைக்கு வருவோம். இலை முனைகளை தனித்தனியாக அச்சிடுவதால் நாங்கள் இலை முனைகளை அச்சிடுவதில்லை. நாங்கள் இடது எல்லையுடன் முடிந்ததும்.

இடது சப்டிரீ இலைகளை மீண்டும் மீண்டும் அச்சிடுவதன் மூலம் இலை முனைகளை அச்சிடுகிறோம். இடது சப்ட்ரீ இலைகளை அச்சிட்ட பிறகு இலைகளை வலது சப்டிரீயில் அச்சிடுங்கள். இந்த வழியில் அனைத்து இலை முனைகளும் கடிகார திசையில் அச்சிடப்படும். இலைகளை அச்சிட்டதும், சரியான எல்லையின் முனைகளை அச்சிடுகிறோம். இந்த நேரத்தில் முனைகளை கீழே-அப் முறையில் அச்சிட வேண்டும். இவ்வாறு உள்ளே மறுநிகழ்வு, முதலில் நாம் மரத்தின் இடது அல்லது வலது சப்டிரீயைத் தீர்த்து, பின்னர் தற்போதைய முனையை pMicrrint செய்கிறோம்.

பைனரி மரத்தின் எல்லை பயணத்தை அச்சிட சி ++ குறியீடு  

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

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

// print the leaves (nodes from the bottom)
void printLeaves(node* root)
{
  if(root){
    // recursively solve the problem for the left subtree
    printLeaves(root->left);
    // if current node is a leaf
    if ((root->left) == NULL && (root->right) == NULL)
      cout<<root->data<<" ";
    // recursively solve the problem for right subtree
    printLeaves(root->right);
  }
}

// print all the nodes of left boundary
// this function will not print the leaves viewed from left side
void printLeft(node* root)
{
  if(root){
    if(root->left != NULL){
      cout<<root->data<<" ";
      // recursively move down the left subtree
      printLeft(root->left);
    }
    else if(root->right){
      cout<<root->data<<" ";
      // recursively move down the right subtree
      printLeft(root->right);
    }
  }
}

// print all the nodes of right boundary
// this function will not print the leaves viewed from the right side
void printRight(node* root)
{
  // printing is done after moving down the tree
  // thus printing is done in bottom up manner
  if(root){
    if (root->right) {
      printRight(root->right);
      cout<<root->data<<" ";
    }
    else if (root->left) {
      printRight(root->left);
      cout<<root->data<<" ";
    }
  }
}

void boundaryUtil(node* root)
{
  // first print the root, then print the left boundary
  // then the leaves which are seen from bottom
  // at last print the right boundary
  if(root){
    cout<<root->data<<" ";
    printLeft(root->left);
    printLeaves(root->left);
    printLeaves(root->right);
    printRight(root->right);
  }
}

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

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

  boundaryUtil(root);
}
5 7 9 1 4 3

பைனரி மரத்தின் எல்லை பயணத்தை அச்சிட ஜாவா குறியீடு  

import java.util.*;

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

class Main{

  // print the leaves (nodes from the bottom)
  static void printLeaves(node root)
  {
    if(root != null){
      // recursively solve the problem for the left subtree
      printLeaves(root.left);
      // if current node is a leaf
      if ((root.left) == null && (root.right) == null)
        System.out.print(root.data+" ");
      // recursively solve the problem for right subtree
      printLeaves(root.right);
    }
  }

  // print all the nodes of left boundary
  // this function will not print the leaves viewed from left side
  static void printLeft(node root)
  {
    if(root != null){
      if(root.left != null){
        System.out.print(root.data+" ");
        // recursively move down the left subtree
        printLeft(root.left);
      }
      else if(root.right != null){
        System.out.print(root.data+" ");
        // recursively move down the right subtree
        printLeft(root.right);
      }
    }
  }

  // print all the nodes of right boundary
  // this function will not print the leaves viewed from the right side
  static void printRight(node root)
  {
    // printing is done after moving down the tree
    // thus printing is done in bottom up manner
    if(root != null){
      if(root.right != null){
        printRight(root.right);
        System.out.print(root.data+" ");
      }
      else if(root.left != null){
        printRight(root.left);
        System.out.print(root.data+" ");
      }
    }
  }

  static void boundaryUtil(node root)
  {
    // first print the root, then print the left boundary
    // then the leaves which are seen from bottom
    // at last print the right boundary
    if(root != null){
      System.out.print(root.data+" ");
      printLeft(root.left);
      printLeaves(root.left);
      printLeaves(root.right);
      printRight(root.right);
    }
  }

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

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

    boundaryUtil(root);
  }
}
5 7 9 1 4 3

சிக்கலான பகுப்பாய்வு  

நேர சிக்கலானது

ஓ (என்), ஏனென்றால், மரத்தின் அனைத்து முனைகளிலும் நாம் பயணித்திருக்கிறோம். நாம் printLeft, printRight மற்றும் printLeaves செயல்பாட்டைப் பயன்படுத்தும்போது முனைகளின் வழியாக பயணிக்கிறோம். இதனால் நேர சிக்கலானது நேரியல்.

மேலும் காண்க
அதன் இணைக்கப்பட்ட பட்டியல் பிரதிநிதித்துவத்திலிருந்து முழுமையான பைனரி மரத்தை உருவாக்குங்கள்

விண்வெளி சிக்கலானது

ஓ (எச்), H என்பது மரத்தின் உயரம். கம்பைலர் ஸ்டேக் இடத்தைப் பயன்படுத்துவதே இதற்குக் காரணம். எல்லைக் கூறுகளை அச்சிடப் பயன்படுத்தப்படும் செயல்பாடுகள் மறுநிகழ்வைப் பயன்படுத்துகின்றன, இது கம்பைலர் அடுக்கைக் கணக்கிடுகிறது.