최소 힙을 최대 힙으로 변환

최소 힙의 배열 표현이 주어지면 이를 최대 힙으로 변환합니다.

예:  

입력: 도착[] = {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의 가장 아래쪽과 가장 오른쪽 내부 노드부터 시작하여 모든 내부 노드를 상향식 방식으로 힙하여 Max 힙을 구축합니다.

문제를 해결하려면 다음 단계를 따르십시오.

  • Min-Heap의 가장 오른쪽 내부 노드에서 Heapify 함수를 호출합니다.
  • 최대 힙을 구축하기 위해 상향식 방식으로 모든 내부 노드를 힙화합니다.
  • 최대 힙 인쇄

연산: 여기에 최소 힙을 최대 힙으로 변환하는 알고리즘 :

  1. 힙의 리프가 아닌 마지막 노드(즉, 마지막 리프 노드의 부모)에서 시작합니다. 이진 힙의 경우 이 노드는 인덱스 Floor((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) 자세한 내용은 다음을 참조하세요. 힙 구축의 시간 복잡도
보조 공간: 에)