Doar puțin probabil îmbinare Sortare , QuickSort este un algoritmul de împărțire și cucerire . Alege un element ca pivot și partiţionează matricea dată în jurul pivotului ales.

Există multe versiuni diferite de quickSort care aleg pivotul în moduri diferite.

1. Alegeți întotdeauna primul element ca pivot
2. Alegeți întotdeauna ultimul element ca pivot
3. Alegeți un element aleatoriu ca pivot
4. Alegeți mediana ca pivot

Aici vom alege ultimul element ca pivot. Procesul cheie din quickSort este partition(). Ținta partițiilor este, având în vedere un tablou și un element „x” al matricei ca pivot, puneți x în poziția corectă într-o matrice sortată și puneți toate elementele mai mici (mai mici decât x) înainte de x și puneți toate elementele mai mari (mai mari decât x) după x. Toate acestea ar trebui făcute în timp liniar.

Piton QuickSort recursiv funcţie

// low -->Index de pornire, // mare --> Index de sfârșit quickSort(arr[], low, high) { // Până când indexul de pornire este mai mic decât indexul de sfârșit dacă (low // pi este index de partiționare, // arr[p] este acum la locul potrivit pi = partition(arr, low, 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)>  
  
  
  
  
 
     
 
     
 
   
 
  Ieșire   
 
  
Unsorted Array [1, 7, 4, 1, 10, 9, -2] Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10] 
  
    Complexitatea timpului:     Cel mai rău caz complexitatea timpului este O(N   2   ) și complexitatea medie a timpului cazului este O(N log N)   
    Spațiu auxiliar:     O(1)  
  
    Python Quicksort folosind         înțelegerea listei       
  
 Sortare rapidă folosind înțelegerea listei este un algoritm recursiv pentru sortarea unei matrice de elemente. Funcționează prin selectarea unui element pivot și partiționarea matricei în jurul pivotului, astfel încât toate elementele mai mici decât pivotul să fie mutate la stânga și toate elementele mai mari decât pivotul să fie mutate la dreapta acestuia. Apoi, aplică recursiv același proces sub-matricelor din stânga și din dreapta până când întreaga matrice este sortată.  
  
    Algoritm:     
  
 1. Dacă matricea de intrare are lungimea 0 sau 1, returnați matricea așa cum este deja sortată.   
 2.Alegeți primul element al matricei ca element pivot.   
 3.Creați două liste goale, stânga și dreapta.   
 4. Pentru fiecare element din matrice, cu excepția pivotului:   
 A. Dacă elementul este mai mic decât pivotul, adăugați-l în lista din stânga.   
 b. Dacă elementul este mai mare sau egal cu pivotul, adăugați-l în lista din dreapta.   
 5.Apelați recursiv sortarea rapidă pe listele din stânga și din dreapta.   
 6.Concatenați lista sortată din stânga, elementul pivot și lista sortată din dreapta.   
 7.Readuceți lista concatenată.  
  
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(stânga) + [pivot] + quicksort(dreapta) # Exemplu de utilizare arr = [1, 7, 4, 1, 10, 9, -2] sorted_arr = quicksort(arr) print('Sorted Array în ordine crescătoare:') print(sorted_arr)>  
  
  
  
  
 
     
 
   
 
     
 
   
 
  Ieșire   
 
  
Sorted Array in Ascending Order: [-2, 1, 1, 4, 7, 9, 10] 
  
 Complexitatea timpului este O(n log n)  
  
 Complexitatea spațială a algoritmului este O(n)