web-dev-qa-db-fra.com

Max-Heapify un arbre binaire

C'est l'une des questions de l'entrevue que j'ai récemment rencontrée. 

Étant donné l’adresse racine d’un arbre binaire complet ou presque complet, nous devons écrire une fonction pour convertir l’arbre en tas-max. 

Il n'y a pas de tableaux impliqués ici. L'arbre est déjà construit.

Pour, par exemple, 

              1   
         /         \
        2           5
      /   \       /   \ 
     3      4    6     7

peut avoir n'importe lequel des tas maximum possibles comme output--

              7   
         /         \
        3           6
      /   \       /   \ 
     2     1     4     5

ou

              7   
         /         \
        4           6
      /   \       /   \ 
     2     3     1     5

etc...

J'ai écrit une solution en utilisant une combinaison de parcours avant et après commande, mais je suppose que cela fonctionne en O (n ^ 2). Mon code donne la sortie suivante.

              7   
         /         \
        3           6
      /   \       /   \ 
     1     2     4     5

Je cherchais une meilleure solution. Quelqu'un peut-il aider s'il vous plaît?

Modifier :

Mon code

void preorder(struct node* root)
{    
    if(root==NULL)return;
    max_heapify(root,NULL);
    preorder(root->left); 
    preorder(root->right);
}
void max_heapify(struct node* root,struct node* prev)
{
    if(root==NULL)
        return ;             
    max_heapify(root->left,root);
    max_heapify(root->right,root);
    if(prev!=NULL && root->data > prev->data)
    {
        swapper(root,prev);
    }     
}
void swapper(struct node* node1, struct node* node2)
{   
    int temp= node1->data;
    node1->data = node2->data;
    node2->data = temp;
}
algorithmdata-structuresheapbinary-treebinary-heap
11
ankitG

Je ne sais pas comment faire si vous ne pouvez pas accéder facilement au nœud parent ou s'il n'y a aucune représentation sous forme de tableau, si vous pouviez parcourir l'arbre pour l'enregistrer dans un tableau (O (N)), cela deviendrait simple.

        1   
     /    \
    2       5
  /   \    / \ 
 3     4  6   7

from the last parent node to the root node(in your case 5,2,1:
  for each node make it compare to their children:
    if children is larger than parent, swap parent and children:
      if swapped: then check the new children's childrens utill no swap

        1   
     /    \
    2       7
  /   \    / \ 
 3     4  6   5    check [7]   5<-->7

        1   
     /    \
    4       7
  /   \    / \ 
 3     2  6   5    check [2]   4<-->2

        7   
     /    \
    4       1
  /   \    / \ 
 3     2  6   5    check [1]   7<-->1

        7   
     /    \
    4       6
  /   \    / \ 
 3     2  1   5    check [1]   6<-->1

C'est ça! La complexité devrait être O (N * LogN).

2
Gohan

Je pense que vous pouvez obtenir un travail simplement en révisant postOrderTraverse. C'est O (n)

void Heapify_Min(TreeNode* node)
{
  if(! = node) return;
   Heapify_Min(node->left);
   Heapify_Min(node->right);
   TreeNode* largest = node;
   if(node->left && node->left->val > node->val)
      largest = node->left;
   if(node->right && node->right->val > node->val)
      largest = node->right;

  if(largest != node)
  {
    swap(node, largest)
  }
}

void swap(TreeNode* n1, TreeNode* n2)
{
    TreeNode* temp = n1->left;
    n1->left = n2->left;
    n2->left =temp;

    temp = n1->right;
    n1->right = n2->right;
    n2->right = temp;
}

}
0
Harry Zhang