Bara osannolikt slå samman Sortera , QuickSort är en dela och erövra algoritm . Den väljer ett element som en pivot och delar upp den givna arrayen runt den valda pivoten.

karta typskript

Det finns många olika versioner av quickSort som väljer pivot på olika sätt.

1. Välj alltid det första elementet som en pivot
2. Välj alltid det sista elementet som en pivot
3. Välj ett slumpmässigt element som en pivot
4. Välj median som en pivot

Här kommer vi att välja det sista elementet som en pivot. Nyckelprocessen i quickSort är partition(). Mål för partitioner är, givet en array och ett element 'x' i array som en pivot, att sätta x i sin korrekta position i en sorterad array och sätta alla mindre element (mindre än x) före x, och sätta alla större element (större än x) efter x. Allt detta bör göras i linjär tid.

Pytonorm Rekursiv QuickSort fungera

// low -->Startindex, // hög --> Slutindex quickSort(arr[], låg, hög) { // Tills startindex är mindre än slutindex om (lågt // pi är partitioneringsindex, // arr[p] är nu på rätt plats pi = partition(arr, low, high); // Before pi quickSort(arr, low, pi - 1) 
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)>
 
 
 
 
    
alfabetet efter siffror
   
 
>
 
  Produktion  
 
Unsorted Array [1, 7, 4, 1, 10, 9, -2] Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10]>
 
    Tidskomplexitet:    Värsta fallet tidskomplexitet är O(N2) och den genomsnittliga falltidskomplexiteten är O(N log N)  
    Hjälputrymme:    O(1)
 
    Python Quicksort med hjälp av         listförståelse      
 
Quicksort med hjälp av listförståelse är en rekursiv algoritm för att sortera en uppsättning element. Det fungerar genom att välja ett pivotelement och partitionera arrayen runt pivoten, så att alla element mindre än pivoten flyttas till vänster och alla element större än pivoten flyttas till höger. Sedan tillämpar den samma process rekursivt på de vänstra och högra sub-arrayerna tills hela arrayen är sorterad.
 
    Algoritm:    
vad är en hashset i java
 
1.Om indatamatrisen har längden 0 eller 1, returnera matrisen eftersom den redan är sorterad.  
2.Välj det första elementet i arrayen som pivotelement.  
3.Skapa två tomma listor, vänster och höger.  
4.För varje element i arrayen förutom pivoten:  
a. Om elementet är mindre än pivoten, lägg till det i den vänstra listan.  
b. Om elementet är större än eller lika med pivoten, lägg till det i den högra listan.  
5.Anropa snabbsortera rekursivt på vänster och höger listor.  
6. Sammanfoga den sorterade vänsterlistan, pivotelementet och den sorterade högerlistan.  
7. Returnera den sammanlänkade listan.
 
Python3
    
 
     
  
 
    
 
     
     
    
java escape karaktär
 
 
 
 
 
 # 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(vänster) + [pivot] + quicksort(höger) # Exempelanvändning arr = [1, 7, 4, 1, 10, 9, -2] sorted_arr = quicksort(arr) print('Sorted Array i stigande ordning:') print(sorted_arr)>
 
 
 
 
    
 
>
 
    
 
>
 
  Produktion  
livscykel för mjukvaruutveckling
 
Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10]>
 
Tidskomplexitet är O(n log n)
 
Algoritmens rymdkomplexitet är O(n)