تحويل الحد الأدنى للكومة إلى الحد الأقصى للكومة

نظرًا لتمثيل صفيف لـ min Heap، قم بتحويله إلى max Heap.

أمثلة:  

مدخل: آر[] = {3 5 9 6 8 20 10 12 18 9}

               3
            /    
          5       9
        /      /  
      6 8 20 10
    /     /
12 18 9 

الإخراج: آر[] = {20 18 10 12 9 9 3 5 6 8}

           20
         /    
      18      10
     /        /  
  12 9 9 3
 /     /
5 6 8 

مدخل: آر[] = {3 4 8 11 13}
الإخراج:  آر[] = {13 11 8 4 3} 

الفكرة ببساطة هي بناء Max Heap دون الاهتمام بالمدخلات. ابدأ من العقدة الداخلية في أقصى اليمين وفي أقصى اليمين لـ Min-Heap وقم بتجميع جميع العقد الداخلية بطريقة من الأسفل إلى الأعلى لإنشاء الكومة القصوى.

اتبع الخطوات المذكورة لحل المشكلة:

  • قم باستدعاء وظيفة Heapify من العقدة الداخلية الموجودة في أقصى اليمين لـ Min-Heap
  • قم بتجميع جميع العقد الداخلية بطريقة تصاعدية لبناء الحد الأقصى من الكومة
  • طباعة ماكس الكومة

الخوارزمية: هنا خوارزمية لتحويل الكومة الدنيا إلى الكومة القصوى :

  1. ابدأ من آخر عقدة غير ورقية في الكومة (أي أصل العقدة الطرفية الأخيرة). بالنسبة للكومة الثنائية، تقع هذه العقدة في طابق الفهرس ((n - 1)/2) حيث n هو عدد العقد في الكومة.
  2. لكل عقدة غير ورقية قم بإجراء "تكديس" عملية لإصلاح خاصية الكومة. في الكومة الدقيقة، تتضمن هذه العملية التحقق مما إذا كانت قيمة العقدة أكبر من قيمة العقد التابعة لها، وإذا كان الأمر كذلك، يتم تبديل العقدة مع العقدة الأصغر منها. في الكومة القصوى، تتضمن العملية التحقق مما إذا كانت قيمة العقدة أقل من قيمة أبنائها وإذا كان الأمر كذلك، فقم بتبديل العقدة مع أكبر أبنائها.
  3. كرر الخطوة 2 لكل من العقد غير الورقية التي تعمل في طريقك إلى أعلى الكومة. عندما تصل إلى جذر الكومة، يجب أن تكون الكومة بأكملها الآن هي الكومة القصوى.

وفيما يلي تنفيذ النهج المذكور أعلاه:

C++
   // A C++ program to convert min Heap to max Heap   #include          using     namespace     std  ;   // to heapify a subtree with root at given index   void     MaxHeapify  (  int     arr  []     int     i       int     N  )   {      int     l     =     2     *     i     +     1  ;      int     r     =     2     *     i     +     2  ;      int     largest     =     i  ;      if     (  l      <     N     &&     arr  [  l  ]     >     arr  [  i  ])      largest     =     l  ;      if     (  r      <     N     &&     arr  [  r  ]     >     arr  [  largest  ])      largest     =     r  ;      if     (  largest     !=     i  )     {      swap  (  arr  [  i  ]     arr  [  largest  ]);      MaxHeapify  (  arr       largest       N  );      }   }   // This function basically builds max heap   void     convertMaxHeap  (  int     arr  []     int     N  )   {      // Start from bottommost and rightmost      // internal node and heapify all internal      // nodes in bottom up way      for     (  int     i     =     (  N     -     2  )     /     2  ;     i     >=     0  ;     --  i  )      MaxHeapify  (  arr       i       N  );   }   // A utility function to print a given array   // of given size   void     printArray  (  int  *     arr       int     size  )   {      for     (  int     i     =     0  ;     i      <     size  ;     ++  i  )      cout      < <     arr  [  i  ]      < <     ' '  ;   }   // Driver's code   int     main  ()   {      // array representing Min Heap      int     arr  []     =     {     3       5       9       6       8       20       10       12       18       9     };      int     N     =     sizeof  (  arr  )     /     sizeof  (  arr  [  0  ]);      printf  (  'Min Heap array : '  );      printArray  (  arr       N  );      // Function call      convertMaxHeap  (  arr       N  );      printf  (  '  n  Max Heap array : '  );      printArray  (  arr       N  );      return     0  ;   }   
C
   // C program to convert min Heap to max Heap   #include         void     swap  (  int  *     a       int  *     b  )   {      int     temp     =     *  a  ;      *  a     =     *  b  ;      *  b     =     temp  ;   }   // to heapify a subtree with root at given index   void     MaxHeapify  (  int     arr  []     int     i       int     N  )   {      int     l     =     2     *     i     +     1  ;      int     r     =     2     *     i     +     2  ;      int     largest     =     i  ;      if     (  l      <     N     &&     arr  [  l  ]     >     arr  [  i  ])      largest     =     l  ;      if     (  r      <     N     &&     arr  [  r  ]     >     arr  [  largest  ])      largest     =     r  ;      if     (  largest     !=     i  )     {      swap  (  &  arr  [  i  ]     &  arr  [  largest  ]);      MaxHeapify  (  arr       largest       N  );      }   }   // This function basically builds max heap   void     convertMaxHeap  (  int     arr  []     int     N  )   {      // Start from bottommost and rightmost      // internal node and heapify all internal      // nodes in bottom up way      for     (  int     i     =     (  N     -     2  )     /     2  ;     i     >=     0  ;     --  i  )      MaxHeapify  (  arr       i       N  );   }   // A utility function to print a given array   // of given size   void     printArray  (  int  *     arr       int     size  )   {      for     (  int     i     =     0  ;     i      <     size  ;     ++  i  )      printf  (  '%d '       arr  [  i  ]);   }   // Driver's code   int     main  ()   {      // array representing Min Heap      int     arr  []     =     {     3       5       9       6       8       20       10       12       18       9     };      int     N     =     sizeof  (  arr  )     /     sizeof  (  arr  [  0  ]);      printf  (  'Min Heap array : '  );      printArray  (  arr       N  );      // Function call      convertMaxHeap  (  arr       N  );      printf  (  '  n  Max Heap array : '  );      printArray  (  arr       N  );      return     0  ;   }   
Java
   // Java program to convert min Heap to max Heap   class   GFG     {      // To heapify a subtree with root at given index      static     void     MaxHeapify  (  int     arr  []       int     i       int     N  )      {      int     l     =     2     *     i     +     1  ;      int     r     =     2     *     i     +     2  ;      int     largest     =     i  ;      if     (  l      <     N     &&     arr  [  l  ]     >     arr  [  i  ]  )      largest     =     l  ;      if     (  r      <     N     &&     arr  [  r  ]     >     arr  [  largest  ]  )      largest     =     r  ;      if     (  largest     !=     i  )     {      // swap arr[i] and arr[largest]      int     temp     =     arr  [  i  ]  ;      arr  [  i  ]     =     arr  [  largest  ]  ;      arr  [  largest  ]     =     temp  ;      MaxHeapify  (  arr       largest       N  );      }      }      // This function basically builds max heap      static     void     convertMaxHeap  (  int     arr  []       int     N  )      {      // Start from bottommost and rightmost      // internal node and heapify all internal      // nodes in bottom up way      for     (  int     i     =     (  N     -     2  )     /     2  ;     i     >=     0  ;     --  i  )      MaxHeapify  (  arr       i       N  );      }      // A utility function to print a given array      // of given size      static     void     printArray  (  int     arr  []       int     size  )      {      for     (  int     i     =     0  ;     i      <     size  ;     ++  i  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }      // driver's code      public     static     void     main  (  String  []     args  )      {      // array representing Min Heap      int     arr  []     =     {     3       5       9       6       8       20       10       12       18       9     };      int     N     =     arr  .  length  ;      System  .  out  .  print  (  'Min Heap array : '  );      printArray  (  arr       N  );      // Function call      convertMaxHeap  (  arr       N  );      System  .  out  .  print  (  'nMax Heap array : '  );      printArray  (  arr       N  );      }   }   // Contributed by Pramod Kumar   
Python3
   # A Python3 program to convert min Heap   # to max Heap   # to heapify a subtree with root   # at given index   def   MaxHeapify  (  arr     i     N  ):   l   =   2   *   i   +   1   r   =   2   *   i   +   2   largest   =   i   if   l    <   N   and   arr  [  l  ]   >   arr  [  i  ]:   largest   =   l   if   r    <   N   and   arr  [  r  ]   >   arr  [  largest  ]:   largest   =   r   if   largest   !=   i  :   arr  [  i  ]   arr  [  largest  ]   =   arr  [  largest  ]   arr  [  i  ]   MaxHeapify  (  arr     largest     N  )   # This function basically builds max heap   def   convertMaxHeap  (  arr     N  ):   # Start from bottommost and rightmost   # internal node and heapify all   # internal nodes in bottom up way   for   i   in   range  (  int  ((  N   -   2  )   /   2  )   -  1     -  1  ):   MaxHeapify  (  arr     i     N  )   # A utility function to print a   # given array of given size   def   printArray  (  arr     size  ):   for   i   in   range  (  size  ):   print  (  arr  [  i  ]   end  =  ' '  )   print  ()   # Driver Code   if   __name__   ==   '__main__'  :   # array representing Min Heap   arr   =   [  3     5     9     6     8     20     10     12     18     9  ]   N   =   len  (  arr  )   print  (  'Min Heap array : '  )   printArray  (  arr     N  )   # Function call   convertMaxHeap  (  arr     N  )   print  (  'Max Heap array : '  )   printArray  (  arr     N  )   # This code is contributed by PranchalK   
C#
   // C# program to convert   // min Heap to max Heap   using     System  ;   class     GFG     {      // To heapify a subtree with      // root at given index      static     void     MaxHeapify  (  int  []     arr       int     i       int     n  )      {      int     l     =     2     *     i     +     1  ;      int     r     =     2     *     i     +     2  ;      int     largest     =     i  ;      if     (  l      <     n     &&     arr  [  l  ]     >     arr  [  i  ])      largest     =     l  ;      if     (  r      <     n     &&     arr  [  r  ]     >     arr  [  largest  ])      largest     =     r  ;      if     (  largest     !=     i  )     {      // swap arr[i] and arr[largest]      int     temp     =     arr  [  i  ];      arr  [  i  ]     =     arr  [  largest  ];      arr  [  largest  ]     =     temp  ;      MaxHeapify  (  arr       largest       n  );      }      }      // This function basically      // builds max heap      static     void     convertMaxHeap  (  int  []     arr       int     n  )      {      // Start from bottommost and      // rightmost internal node and      // heapify all internal nodes      // in bottom up way      for     (  int     i     =     (  n     -     2  )     /     2  ;     i     >=     0  ;     --  i  )      MaxHeapify  (  arr       i       n  );      }      // A utility function to print      // a given array of given size      static     void     printArray  (  int  []     arr       int     size  )      {      for     (  int     i     =     0  ;     i      <     size  ;     ++  i  )      Console  .  Write  (  arr  [  i  ]     +     ' '  );      }      // Driver's Code      public     static     void     Main  ()      {      // array representing Min Heap      int  []     arr     =     {     3       5       9       6       8       20       10       12       18       9     };      int     n     =     arr  .  Length  ;      Console  .  Write  (  'Min Heap array : '  );      printArray  (  arr       n  );      // Function call      convertMaxHeap  (  arr       n  );      Console  .  Write  (  'nMax Heap array : '  );      printArray  (  arr       n  );      }   }   // This code is contributed by nitin mittal.   
JavaScript
    <  script  >   // javascript program to convert min Heap to max Heap    // To heapify a subtree with root at given index   function     MaxHeapify  (  arr          i          n  )   {      var     l     =     2  *  i     +     1  ;      var     r     =     2  *  i     +     2  ;      var     largest     =     i  ;      if     (  l      <     n     &&     arr  [  l  ]     >     arr  [  i  ])      largest     =     l  ;      if     (  r      <     n     &&     arr  [  r  ]     >     arr  [  largest  ])      largest     =     r  ;      if     (  largest     !=     i  )      {      // swap arr[i] and arr[largest]      var     temp     =     arr  [  i  ];      arr  [  i  ]     =     arr  [  largest  ];      arr  [  largest  ]     =     temp  ;      MaxHeapify  (  arr       largest       n  );      }   }   // This function basically builds max heap   function     convertMaxHeap  (  arr          n  )   {      // Start from bottommost and rightmost      // internal node and heapify all internal      // nodes in bottom up way      for     (  i     =     (  n  -  2  )  /  2  ;     i     >=     0  ;     --  i  )      MaxHeapify  (  arr       i       n  );   }   // A utility function to print a given array   // of given size   function     printArray  (  arr          size  )   {      for     (  i     =     0  ;     i      <     size  ;     ++  i  )      document  .  write  (  arr  [  i  ]  +  ' '  );   }   // driver program   // array representing Min Heap   var     arr     =     [  3       5       9       6       8       20       10       12       18       9  ];   var     n     =     arr  .  length  ;   document  .  write  (  'Min Heap array : '  );   printArray  (  arr       n  );   convertMaxHeap  (  arr       n  );   document  .  write  (  '  
Max Heap array : '
); printArray ( arr n ); // This code is contributed by 29AjayKumar < /script>
PHP
      // A PHP program to convert min Heap to max Heap   // utility swap function   function   swap  (  &  $a    &  $b  )   {   $tmp  =  $a  ;   $a  =  $b  ;   $b  =  $tmp  ;   }   // to heapify a subtree with root at given index   function   MaxHeapify  (  &  $arr     $i     $n  )   {   $l   =   2  *  $i   +   1  ;   $r   =   2  *  $i   +   2  ;   $largest   =   $i  ;   if   (  $l    <   $n   &&   $arr  [  $l  ]   >   $arr  [  $i  ])   $largest   =   $l  ;   if   (  $r    <   $n   &&   $arr  [  $r  ]   >   $arr  [  $largest  ])   $largest   =   $r  ;   if   (  $largest   !=   $i  )   {   swap  (  $arr  [  $i  ]   $arr  [  $largest  ]);   MaxHeapify  (  $arr     $largest     $n  );   }   }   // This function basically builds max heap   function   convertMaxHeap  (  &  $arr     $n  )   {   // Start from bottommost and rightmost   // internal node and heapify all internal   // nodes in bottom up way   for   (  $i   =   (  int  )((  $n  -  2  )  /  2  );   $i   >=   0  ;   --  $i  )   MaxHeapify  (  $arr     $i     $n  );   }   // A utility function to print a given array   // of given size   function   printArray  (  $arr     $size  )   {   for   (  $i   =   0  ;   $i    <  $size  ;   ++  $i  )   print  (  $arr  [  $i  ]  .  ' '  );   }   // Driver code   // array representing Min Heap   $arr   =   array  (  3     5     9     6     8     20     10     12     18     9  );   $n   =   count  (  $arr  );   print  (  'Min Heap array : '  );   printArray  (  $arr     $n  );   convertMaxHeap  (  $arr     $n  );   print  (  '  n  Max Heap array : '  );   printArray  (  $arr     $n  );   // This code is contributed by mits   ?>   

الإخراج
Min Heap array : 3 5 9 6 8 20 10 12 18 9 Max Heap array : 20 18 10 12 9 9 3 5 6 8  

تعقيد الوقت: O(N) للحصول على التفاصيل يرجى الرجوع إلى: التعقيد الزمني لبناء الكومة
المساحة المساعدة: على)