بالنظر إلى قائمة الأعداد الصحيحة، قم بإعادة ترتيب القائمة بحيث تتكون من عناصر الحد الأدنى المتناوبة باستخدام عمليات القائمة فقط . يجب أن يكون العنصر الأول في القائمة هو الحد الأدنى والعنصر الثاني يجب أن يكون الحد الأقصى لجميع العناصر الموجودة في القائمة. وبالمثل فإن العنصر الثالث سيكون العنصر الأدنى التالي والعنصر الرابع هو العنصر الأقصى التالي وهكذا. لا يسمح باستخدام مساحة إضافية. أمثلة:

    Input:      [1 3 8 2 7 5 6 4]   
    Output:     [1 8 2 7 3 6 4 5]   
    Input:      [1 2 3 4 5 6 7]   
    Output:     [1 7 2 6 3 5 4]   
    Input:      [1 6 2 5 3 4]   
    Output:     [1 6 2 5 3 4]   
Recommended Practice  إعادة ترتيب المصفوفة    جربه!   
 الفكرة هي فرز القائمة بترتيب تصاعدي أولاً. ثم نبدأ في ظهور العناصر من نهاية القائمة وإدراجها في مكانها الصحيح في القائمة. وفيما يلي تنفيذ الفكرة المذكورة أعلاه -   
 C++   
   // C++ program to rearrange a given list such that it    // consists of alternating minimum maximum elements    #include             using     namespace     std  ;      // Function to rearrange a given list such that it    // consists of alternating minimum maximum elements    void     alternateSort  (  list   <  int  >&     inp  )      {         // sort the list in ascending order       inp  .  sort  ();         // get iterator to first element of the list       list   <  int  >::  iterator     it     =     inp  .  begin  ();         it  ++  ;         for     (  int     i  =  1  ;     i   <  (  inp  .  size  ()     +     1  )  /  2  ;     i  ++  )         {         // pop last element (next greatest)       int     val     =     inp  .  back  ();         inp  .  pop_back  ();         // insert it after next minimum element       inp  .  insert  (  it       val  );         // increment the pointer for next pair       ++  it  ;         }      }      // Driver code    int     main  ()      {         // input list       list   <  int  >     inp  ({     1       3       8       2       7       5       6       4     });         // rearrange the given list       alternateSort  (  inp  );         // print the modified list       for     (  int     i     :     inp  )         cout      < <     i      < <     ' '  ;         return     0  ;      }      
  Java   
   // Java program to rearrange a given list such that it   // consists of alternating minimum maximum elements   import     java.util.*  ;   class   AlternateSort   {      // Function to rearrange a given list such that it      // consists of alternating minimum maximum elements      // using LinkedList      public     static     void     alternateSort  (  LinkedList   <  Integer  >     ll  )         {      Collections  .  sort  (  ll  );          for     (  int     i     =     1  ;     i      <     (  ll  .  size  ()     +     1  )  /  2  ;     i  ++  )      {      Integer     x     =     ll  .  getLast  ();      ll  .  removeLast  ();      ll  .  add  (  2  *  i     -     1       x  );      }          System  .  out  .  println  (  ll  );      }          public     static     void     main     (  String  []     args  )     throws     java  .  lang  .  Exception      {      // input list      Integer     arr  []     =     {  1       3       8       2       7       5       6       4  };          // convert array to LinkedList      LinkedList   <  Integer  >     ll     =     new     LinkedList   <  Integer  >  (  Arrays  .  asList  (  arr  ));          // rearrange the given list      alternateSort  (  ll  );      }   }   
  Python   
   # Python program to rearrange a given list such that it   # consists of alternating minimum maximum elements   inp   =   []   # Function to rearrange a given list such that it   # consists of alternating minimum maximum elements   def   alternateSort  ():   global   inp   # sort the list in ascending order   inp  .  sort  ()   # get index to first element of the list   it   =   0   it   =   it   +   1   i   =   1   while   (   i    <   (  len  (  inp  )   +   1  )  /  2   ):   i   =   i   +   1   # pop last element (next greatest)   val   =   inp  [  -  1  ]   inp  .  pop  ()   # insert it after next minimum element   inp  .  insert  (  it     val  )   # increment the pointer for next pair   it   =   it   +   2   # Driver code   # input list   inp  =  [   1     3     8     2     7     5     6     4   ]   # rearrange the given list   alternateSort  ()   # print the modified list   print   (  inp  )   # This code is contributed by Arnab Kundu   
  C#   
   // C# program to rearrange a given list such that it   // consists of alternating minimum maximum elements    using     System  ;      using     System.Collections.Generic  ;   class     GFG   {      // Function to rearrange a given list such that it      // consists of alternating minimum maximum elements      // using List      public     static     void     alternateSort  (  List   <  int  >     ll  )         {      ll  .  Sort  ();          for     (  int     i     =     1  ;     i      <     (  ll  .  Count     +     1  )  /  2  ;     i  ++  )      {      int     x     =     ll  [  ll  .  Count  -  1  ];      ll  .  RemoveAt  (  ll  .  Count  -  1  );      ll  .  Insert  (  2  *  i     -     1       x  );      }      foreach  (  int     a     in     ll  )      {      Console  .  Write  (  a  +  ' '  );      }          }          // Driver code      public     static     void     Main     (  String  []     args  )      {      // input list      int     []  arr     =     {  1       3       8       2       7       5       6       4  };          // convert array to List      List   <  int  >     ll     =     new     List   <  int  >  (  arr  );          // rearrange the given list      alternateSort  (  ll  );      }   }   /* This code contributed by PrinciRaj1992 */   
  JavaScript   
    <  script  >   // JavaScript program to rearrange a given list such that it   // consists of alternating minimum maximum elements   let     inp     =     []   // Function to rearrange a given list such that it   // consists of alternating minimum maximum elements   function     alternateSort  (){      // sort the list in ascending order      inp  .  sort  ()      // get index to first element of the list      let     it     =     0      it     =     it     +     1          let     i     =     1          while     (     i      <     (  inp  .  length     +     1  )  /  2     ){          i     =     i     +     1          // pop last element (next greatest)      let     val     =     inp  [  inp  .  length  -  1  ]      inp  .  pop  ()      // insert it after next minimum element      inp  .  splice  (  it    0       val  )      // increment the pointer for next pair      it     =     it     +     2      }   }       // Driver code   // input list   inp  =  [     1       3       8       2       7       5       6       4     ]   // rearrange the given list   alternateSort  ()   // print the modified list   for  (  let     x     of     inp  ){      document  .  write  (  x    ' '  )   }   // This code is contributed by shinjanpatra    <  /script>   
    
  الإخراج   
1 8 2 7 3 6 4 5  
 
    تعقيد الوقت:    O(N*logN) لأننا نستخدم دالة الفرز.   
    المساحة المساعدة:    O(1) لأننا لا نستخدم مساحة إضافية.  
  
    
  
 النهج رقم 2: استخدام النوع ()  
 
 فرز القائمة المحددة بترتيب تصاعدي، تهيئة قائمة نتائج فارغة، التكرار على أكثر من نصف مؤشرات القائمة التي تم فرزها: إلحاق العنصر من الفهرس الحالي والعنصر المقابل من نهاية القائمة، إذا كان طول القائمة الأصلية غريبًا، قم بإلحاق العنصر الأوسط بقائمة النتائج، قم بتحويل قائمة النتائج إلى سلسلة بأعداد صحيحة مفصولة بمسافات  
  
 خوارزمية  
 
 1. قم بفرز القائمة باستخدام الدالةsort()    
 2. تهيئة قائمة نتائج فارغة   
 3. قم بالتمرير عبر نطاق النصف الأول من القائمة   
 4. قم بإلحاق العنصر i بالقائمة التي تم فرزها   
 5. قم بإلحاق العنصر (-i-1) بالقائمة التي تم فرزها   
 6. إذا كان طول القائمة الأصلية فرديًا، قم بإلحاق العنصر الأوسط بقائمة النتائج   
 7. قم بتحويل قائمة النتائج إلى سلسلة باستخدام الدالة join()   
 C++   
   #include          #include          #include         using     namespace     std  ;   string     alternateMinMax  (  vector   <  int  >     lst  )     {      sort  (  lst  .  begin  ()     lst  .  end  ());      vector   <  int  >     res  ;      for     (  int     i     =     0  ;     i      <     lst  .  size  ()     /     2  ;     i  ++  )     {      res  .  push_back  (  lst  [  i  ]);      res  .  push_back  (  lst  [  lst  .  size  ()     -     i     -     1  ]);      }      if     (  lst  .  size  ()     %     2     ==     1  )     {      res  .  push_back  (  lst  [  lst  .  size  ()     /     2  ]);      }      string     result     =     ''  ;      for     (  int     i     =     0  ;     i      <     res  .  size  ();     i  ++  )     {      result     +=     to_string  (  res  [  i  ])     +     ' '  ;      }      return     result  ;   }   int     main  ()     {      vector   <  int  >     lst     =     {  1       3       8       2       7       5       6       4  };      cout      < <     alternateMinMax  (  lst  )      < <     endl  ;      return     0  ;   }   
  Java   
   import     java.util.ArrayList  ;   import     java.util.Collections  ;   import     java.util.List  ;   public     class   AlternateMinMax     {      // Function to rearrange a list of integers in alternating min-max order      public     static     String     alternateMinMax  (  List   <  Integer  >     lst  )     {      // Sort the input list in ascending order      Collections  .  sort  (  lst  );              List   <  Integer  >     res     =     new     ArrayList   <>  ();          // Iterate through the first half of the sorted list      for     (  int     i     =     0  ;     i      <     lst  .  size  ()     /     2  ;     i  ++  )     {          res  .  add  (  lst  .  get  (  i  ));      res  .  add  (  lst  .  get  (  lst  .  size  ()     -     i     -     1  ));      }          // If the input list has an odd number of elements add the middle element      if     (  lst  .  size  ()     %     2     ==     1  )     {      res  .  add  (  lst  .  get  (  lst  .  size  ()     /     2  ));      }          // Create a StringBuilder to build the result string      StringBuilder     result     =     new     StringBuilder  ();          // Append each element from the rearranged list to the result string      for     (  int     i     =     0  ;     i      <     res  .  size  ();     i  ++  )     {      result  .  append  (  res  .  get  (  i  )).  append  (  ' '  );      }              return     result  .  toString  ();      }      public     static     void     main  (  String  []     args  )     {      // Create a list of integers      List   <  Integer  >     lst     =     new     ArrayList   <>  ();      lst  .  add  (  1  );      lst  .  add  (  3  );      lst  .  add  (  8  );      lst  .  add  (  2  );      lst  .  add  (  7  );      lst  .  add  (  5  );      lst  .  add  (  6  );      lst  .  add  (  4  );          // Call the alternateMinMax function and print the result      System  .  out  .  println  (  alternateMinMax  (  lst  ));      }   }   
  Python3   
   def   alternate_min_max  (  lst  ):   lst  .  sort  ()   res   =   []   for   i   in   range  (  len  (  lst  )   //   2  ):   res  .  append  (  lst  [  i  ])   res  .  append  (  lst  [  -  i  -  1  ])   if   len  (  lst  )   %   2   ==   1  :   res  .  append  (  lst  [  len  (  lst  )   //   2  ])   return   ' '  .  join  (  map  (  str     res  ))   lst   =   [  1     3     8     2     7     5     6     4  ]   print  (  alternate_min_max  (  lst  ))   
  C#   
   using     System  ;   using     System.Collections.Generic  ;   using     System.Linq  ;   public     class     GFG   {      public     static     string     GetAlternateMinMax  (  List   <  int  >     lst  )      {      // Sort the list in ascending order      lst  .  Sort  ();      List   <  int  >     res     =     new     List   <  int  >  ();      int     n     =     lst  .  Count  ;      // Create the alternating min-max list      for     (  int     i     =     0  ;     i      <     n     /     2  ;     i  ++  )      {      res  .  Add  (  lst  [  i  ]);      res  .  Add  (  lst  [  n     -     i     -     1  ]);      }      // If the list has an odd number of elements add the middle element      if     (  n     %     2     ==     1  )      {      res  .  Add  (  lst  [  n     /     2  ]);      }      // Convert the result list to a string      string     result     =     string  .  Join  (  ' '       res  );      return     result  ;      }      public     static     void     Main  (  string  []     args  )      {      List   <  int  >     lst     =     new     List   <  int  >     {     1       3       8       2       7       5       6       4     };      string     result     =     GetAlternateMinMax  (  lst  );      Console  .  WriteLine  (  result  );      }   }   
  JavaScript   
   function     alternateMinMax  (  lst  )     {      lst  .  sort  ((  a       b  )     =>     a     -     b  );      // Initialize an empty array to       // store the result      const     res     =     [];      for     (  let     i     =     0  ;     i      <     Math  .  floor  (  lst  .  length     /     2  );     i  ++  )     {      // Push the minimum element from the beginning      res  .  push  (  lst  [  i  ]);      res  .  push  (  lst  [  lst  .  length     -     i     -     1  ]);      }      // If the length of the list is odd      // push the middle element      if     (  lst  .  length     %     2     ===     1  )     {      res  .  push  (  lst  [  Math  .  floor  (  lst  .  length     /     2  )]);      }      // Convert the result array to a       // space-separated string      const     result     =     res  .  join  (  ' '  );      return     result  ;   }   // Input list   const     lst     =     [  1       3       8       2       7       5       6       4  ];   console  .  log  (  alternateMinMax  (  lst  ));   
    
  الإخراج   
1 8 2 7 3 6 4 5 
 
 تعقيد الوقت: O(nlogn) بسبب عملية الفرز. تتكرر حلقة for أكثر من نصف القائمة مما يستغرق وقتًا O(n/2). يستغرق تحويل قائمة النتائج إلى سلسلة وقتًا O(n). نظرًا لأن O(nlogn) أكبر من O(n)، فإن التعقيد الزمني الإجمالي هو O(n*logn).  
  
 المساحة المساعدة: O(n) لأن القائمة التي تم فرزها وقائمة النتائج تأخذ مساحة O(n). المساحة المستخدمة بواسطة المتغيرات المستخدمة في الدالة ثابتة ولا تعتمد على حجم قائمة الإدخال.