Semplicemente improbabile unisci Ordina , QuickSort è un file algoritmo divide et impera . Seleziona un elemento come pivot e suddivide l'array specificato attorno al pivot selezionato.

Esistono molte versioni diverse di quickSort che scelgono il pivot in modi diversi.

1. Scegli sempre il primo elemento come pivot
2. Scegli sempre l'ultimo elemento come pivot
3. Scegli un elemento casuale come pivot
4. Scegli la mediana come perno

Qui sceglieremo l'ultimo elemento come perno. Il processo chiave in quickSort è partizione(). L'obiettivo delle partizioni è, dato un array e un elemento 'x' dell'array come perno, mettere x nella sua posizione corretta in un array ordinato e mettere tutti gli elementi più piccoli (minori di x) prima di x, e mettere tutti gli elementi maggiori (maggiori di x) dopo x. Tutto questo dovrebbe essere fatto in tempo lineare.

Pitone QuickSort ricorsivo funzione

// low -->Indice iniziale, // alto --> Indice finale quickSort(arr[], basso, alto) { // Fino all'indice iniziale è minore dell'indice finale se (basso // pi è l'indice di partizionamento, // arr[p] è ora al posto giusto pi = partizione(arr, low, high); // Prima di 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)>  
  
  
  
  
 
     
 
     
 
   
 
  Produzione   
 
  
Unsorted Array [1, 7, 4, 1, 10, 9, -2] Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10] 
  
    Complessità temporale:     La complessità temporale nel caso peggiore è O(N   2   ) e la complessità temporale media del caso è O(N log N)   
    Spazio ausiliario:     O(1)  
  
    Python Quicksort utilizzando         comprensione delle liste       
  
 Quicksort che utilizza la comprensione delle liste è un algoritmo ricorsivo per l'ordinamento di una serie di elementi. Funziona selezionando un elemento pivot e suddividendo l'array attorno al pivot, in modo tale che tutti gli elementi inferiori al pivot vengano spostati alla sua sinistra e tutti gli elementi maggiori del pivot vengano spostati alla sua destra. Quindi, applica in modo ricorsivo lo stesso processo ai sottoarray sinistro e destro finché l'intero array non viene ordinato.  
  
    Algoritmo:     
  
 1.Se l'array di input ha lunghezza 0 o 1, restituisce l'array così come è già ordinato.   
 2.Scegli il primo elemento dell'array come elemento pivot.   
 3.Crea due elenchi vuoti, sinistro e destro.   
 4.Per ogni elemento dell'array tranne il pivot:   
 UN. Se l'elemento è più piccolo del pivot, aggiungilo all'elenco a sinistra.   
 B. Se l'elemento è maggiore o uguale al pivot, aggiungilo all'elenco di destra.   
 5.Chiama ricorsivamente Quicksort negli elenchi di sinistra e di destra.   
 6.Concatenare l'elenco ordinato di sinistra, l'elemento pivot e l'elenco ordinato di destra.   
 7.Restituisce l'elenco concatenato.  
  
Python3 
     
 
  
     
   
  
     
  
     
     
     
  
 
  
  
  
  
  # 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(sinistra) + [pivot] + quicksort(destra) # Esempio di utilizzo arr = [1, 7, 4, 1, 10, 9, -2] sorted_arr = quicksort(arr) print('Array ordinato in ordine crescente:') print(sorted_arr)>  
  
  
  
  
 
     
 
   
 
     
 
   
 
  Produzione   
 
  
Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10] 
  
 La complessità temporale è O(n log n)  
  
 La complessità spaziale dell'algoritmo è O(n)