Gewoon onwaarschijnlijk samenvoegen Sorteren , QuickSort is een verdeel en heers algoritme . Het kiest een element als draaipunt en verdeelt de gegeven array rond het gekozen draaipunt.

java converteert naar string

Er zijn veel verschillende versies van quickSort die op verschillende manieren een draaipunt kiezen.

1. Kies altijd het eerste element als draaipunt
2. Kies altijd het laatste element als draaipunt
3. Kies een willekeurig element als draaipunt
4. Kies de mediaan als draaipunt

Hier kiezen we het laatste element als draaipunt. Het belangrijkste proces in quickSort is partitie(). Het doel van partities is, gegeven een array en een element 'x' van array als draaipunt, x op de juiste positie in een gesorteerde array te plaatsen en alle kleinere elementen (kleiner dan x) vóór x te plaatsen, en alle grotere elementen (grotere elementen) te plaatsen. dan x) na x. Dit alles zou in lineaire tijd moeten gebeuren.

Python Recursieve QuickSort functie

// low -->Startindex, // hoog --> Eindindex quickSort(arr[], laag, hoog) {/ // Tot de startindex kleiner is dan de eindindex if (laag // pi is een partitie-index, // arr[p] is nu op de juiste plaats pi = partitie(arr, low, high); // Vóór pi quickSort(arr, low, pi - 1); // Na pi quickSort(arr, pi + 1, high); 
Python3
    
 
     
  
 
 

 
    
 
     
     
    
 
 
 

 
 
 
 
 # Python program for implementation of Quicksort Sort> # This implementation utilizes pivot as the last element in the nums list> # It has a pointer to keep track of the elements smaller than the pivot> # At the very end of partition() function, the pointer is swapped with the pivot> # to come up with a 'sorted' nums relative to the pivot> # Function to find the partition position> def> partition(array, low, high):> ># choose the rightmost element as pivot> >pivot>=> array[high]> ># pointer for greater element> >i>=> low>-> 1> ># traverse through all elements> ># compare each element with pivot> >for> j>in> range>(low, high):> >if> array[j] <>=> pivot:> ># If element smaller than pivot is found> ># swap it with the greater element pointed by i> >i>=> i>+> 1> ># Swapping element at i with element at j> >(array[i], array[j])>=> (array[j], array[i])> ># Swap the pivot element with the greater element specified by i> >(array[i>+> 1>], array[high])>=> (array[high], array[i>+> 1>])> ># Return the position from where partition is done> >return> i>+> 1> # function to perform quicksort> def> quickSort(array, low, high):> >if> low   # Find pivot element such that  # element smaller than pivot are on the left  # element greater than pivot are on the right  pi = partition(array, low, high)  # Recursive call on the left of pivot  quickSort(array, low, pi - 1)  # Recursive call on the right of pivot  quickSort(array, pi + 1, high) data = [1, 7, 4, 1, 10, 9, -2] print('Unsorted Array') print(data) size = len(data) quickSort(data, 0, size - 1) print('Sorted Array in Ascending Order:') print(data)>
 
 
 
 
    
   
tekenreeks in c++
 
>
 
  Uitvoer  
 
Unsorted Array [1, 7, 4, 1, 10, 9, -2] Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10]>
 
    Tijdcomplexiteit:    In het slechtste geval is de tijdscomplexiteit O(N2) en de gemiddelde complexiteit van de casustijd is O(N log N)  
    Hulpruimte:    O(1)
 
    Python Quicksort gebruikt         lijst begrip      
 
Quicksort met behulp van lijstbegrip is een recursief algoritme voor het sorteren van een reeks elementen. Het werkt door een draaielement te selecteren en de array rond het draaipunt te verdelen, zodat alle elementen kleiner dan het draaipunt naar links worden verplaatst en alle elementen die groter zijn dan het draaipunt naar rechts worden verplaatst. Vervolgens past het hetzelfde proces recursief toe op de linker en rechter subarrays totdat de hele array is gesorteerd.
 
    Algoritme:    
lijsten in Java
 
1.Als de invoerarray lengte 0 of 1 heeft, retourneert u de array zoals deze al is gesorteerd.  
2.Kies het eerste element van de array als draaielement.  
3.Maak twee lege lijsten, links en rechts.  
4.Voor elk element in de array, behalve het draaipunt:  
A. Als het element kleiner is dan het draaipunt, voegt u het toe aan de linkerlijst.  
B. Als het element groter is dan of gelijk is aan het draaipunt, voeg het dan toe aan de rechterlijst.  
5. Roep recursief quicksort aan in de linker- en rechterlijsten.  
6. Voeg de gesorteerde linkerlijst, het draaielement en de gesorteerde rechterlijst samen.  
7. Retourneer de samengevoegde lijst.
 
Python3
    
 
     
  
gimp exporteren als jpg
 
    
 
     
     
    
 
 
 
 
 
 # Approach 2: Quicksort using list comprehension> def> quicksort(arr):> >if> len>(arr) <>=> 1>:> >return> arr> >else>:> >pivot>=> arr[>0>]> >left>=> [x>for> x>in> arr[>1>:]>if> x   right = [x for x in arr[1:] if x>= pivot] return quicksort(left) + [pivot] + quicksort(right) # Voorbeeldgebruik arr = [1, 7, 4, 1, 10, 9, -2] sorted_arr = quicksort(arr) print('Sorted Array in oplopende volgorde:') print(sorted_arr)>
 
 
 
 
    
 
>
 
    
 
>
 
  Uitvoer  
stapel Java
 
Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10]>
 
Tijdcomplexiteit is O(n log n)
 
De ruimtecomplexiteit van het algoritme is O(n)