#practiceLinkDiv { display: none !important; }Ordnen Sie bei einer gegebenen Liste von ganzen Zahlen die Liste so um, dass sie aus abwechselnden Minimum-Maximum-Elementen besteht nur Listenoperationen verwenden . Das erste Element der Liste sollte das Minimum und das zweite Element das Maximum aller in der Liste vorhandenen Elemente sein. Ebenso ist das dritte Element das nächste minimale Element und das vierte Element das nächste maximale Element und so weiter. Die Nutzung zusätzlicher Flächen ist nicht gestattet. Beispiele:
Input: [1 3 8 2 7 5 6 4]Recommended Practice Array neu anordnen Probieren Sie es aus!
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]
Die Idee besteht darin, die Liste zunächst in aufsteigender Reihenfolge zu sortieren. Dann beginnen wir damit, Elemente vom Ende der Liste zu entfernen und sie an der richtigen Position in der Liste einzufügen. Nachfolgend finden Sie die Umsetzung der obigen Idee:
C++
// C++ program to rearrange a given list such that it // consists of alternating minimum maximum elements #include
// 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 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# 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 */
<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(it0 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>
Ausgabe
1 8 2 7 3 6 4 5
Zeitkomplexität: O(N*logN), da wir eine Sortierfunktion verwenden.
Hilfsraum: O(1), da wir keinen zusätzlichen Platz verbrauchen.
Ansatz Nr. 2: Verwenden von sort()
Sortieren Sie die angegebene Liste in aufsteigender Reihenfolge. Initialisieren Sie eine leere Ergebnisliste. Iterieren Sie über die Hälfte der sortierten Listenindizes: Hängen Sie das Element vom aktuellen Index und das entsprechende Element vom Ende der Liste an. Wenn die Länge der ursprünglichen Liste ungerade ist, hängen Sie das mittlere Element an die Ergebnisliste an. Konvertieren Sie die Ergebnisliste in eine Zeichenfolge mit durch Leerzeichen getrennten Ganzzahlen
Algorithmus
1. Sortieren Sie die Liste mit der Funktion sort()
2. Initialisieren Sie eine leere Ergebnisliste
3. Durchlaufen Sie den Bereich der ersten Hälfte der Liste
4. Hängen Sie das i-te Element der sortierten Liste an
5. Hängen Sie das (-i-1)-te Element der sortierten Liste an
6. Wenn die Länge der Originalliste ungerade ist, hängen Sie das mittlere Element an die Ergebnisliste an
7. Konvertieren Sie die Ergebnisliste mithilfe der Funktion „join()“ in einen String
#include
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)); } }
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))
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); } }
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));
Ausgabe
1 8 2 7 3 6 4 5
Zeitkomplexität: O(nlogn) wegen der Sortieroperation. Die for-Schleife durchläuft mehr als die Hälfte der Liste, was O(n/2) Zeit benötigt. Die Konvertierung der Ergebnisliste in einen String dauert O(n) Zeit. Da O(nlogn) größer als O(n) ist, beträgt die Gesamtzeitkomplexität O(n*logn).
Hilfsraum: O(n), da sowohl die sortierte Liste als auch die Ergebnisliste O(n) Platz beanspruchen. Der von den in der Funktion verwendeten Variablen beanspruchte Speicherplatz ist konstant und hängt nicht von der Größe der Eingabeliste ab.