Автор оригинала: Pankaj Kumar.
Как сортировать массив в Python
Массивы Python могут быть отсортированы с использованием различных алгоритмов сортировки, изменяющиеся в результате выполнения и эффективности, основанной на выбранном алгоритме. Мы расследуем некоторые из этих подходов к элементам сортировки массива.
Использование сортировки () на Python Tireable объекты
Python использует некоторые чрезвычайно эффективные алгоритмы для выполнения сортировки. отсортировано () Способ, например, использует алгоритм под названием Timsort (который представляет собой комбинацию сортировки вставки и сортировки слияния) для выполнения высоко оптимизированной сортировки.
Любой объект Python Iterable, такой как список или массив, можно отсортировать с помощью этого метода.
import array
# Declare a list type object
list_object = [3, 4, 1, 5, 2]
# Declare an integer array object
array_object = array.array('i', [3, 4, 1, 5, 2])
print('Sorted list ->', sorted(list_object))
print('Sorted array ->', sorted(array_object))
Выход:
Sorted list -> [1, 2, 3, 4, 5] Sorted array -> [1, 2, 3, 4, 5]
Реализация Mergeort и Quicksort
Здесь мы расследуем два других обычно используемых метода сортировки, используемые в реальной практике, а именно МЕРГОРТ и QuickSort алгоритмы.
1. Алгоритм Мергеорта
Алгоритм использует подход к снизу и победу и завоевании снизу вверх, сначала разделяя исходный массив в подчинители, а затем объединение индивидуально отсортированных помех для давления окончательного отсортированного массива.
На следующем фрагменте кода Mergesort_Helper () Метод делает фактическое расщепление в подчиненные и метод Performent_Merge () объединяет две ранее отсортированные массивы в новый отсортированный массив.
import array
def mergesort(a, arr_type):
def perform_merge(a, arr_type, start, mid, end):
# Merges two previously sorted arrays
# a[start:mid] and a[mid:end]
tmp = array.array(arr_type, [i for i in a])
def compare(tmp, i, j):
if tmp[i] <= tmp[j]:
i += 1
return tmp[i-1]
else:
j += 1
return tmp[j-1]
i = start
j = mid + 1
curr = start
while i<=mid or j<=end:
if i<=mid and j<=end:
if tmp[i] <= tmp[j]:
a[curr] = tmp[i]
i += 1
else:
a[curr] = tmp[j]
j += 1
elif i==mid+1 and j<=end:
a[curr] = tmp[j]
j += 1
elif j == end+1 and i<=mid:
a[curr] = tmp[i]
i += 1
elif i > mid and j > end:
break
curr += 1
def mergesort_helper(a, arr_type, start, end):
# Divides the array into two parts
# recursively and merges the subarrays
# in a bottom up fashion, sorting them
# via Divide and Conquer
if start < end:
mergesort_helper(a, arr_type, start, (end + start)//2)
mergesort_helper(a, arr_type, (end + start)//2 + 1, end)
perform_merge(a, arr_type, start, (start + end)//2, end)
# Sorts the array using mergesort_helper
mergesort_helper(a, arr_type, 0, len(a)-1)
Тестовый случай :
a = array.array('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
print('Before MergeSort ->', a)
mergesort(a, 'i')
print('After MergeSort ->', a)
Выход:
Before MergeSort -> array('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
After MergeSort -> array('i', [1, 1, 2, 3, 3, 4, 5, 6, 7, 12])
2. Алгоритм Quicksort
Этот алгоритм также использует стратегию Divide и Conquer, но вместо этого использует подход сверху вниз, сначала разделяя массив вокруг A Удар Элемент (здесь мы всегда выбираем последний элемент массива, чтобы быть поворотом).
Таким образом, гарантируя, что после каждого шага поворачивается на его обозначенном положении в финальном отсортированном массиве.
После обеспечения того, чтобы массив распределял вокруг поворота (элементы меньше, чем у поворота, находятся влево, и элементы, которые больше, чем у поворота, находятся вправо), мы продолжаем применять Раздел Функция до остальной части массива, пока все элементы не находятся в соответствующей позиции, что является когда массив полностью отсортирован.
Примечание : Есть и другие подходы к этому алгоритму для выбора элемента поворота. Некоторые варианты выбирают медианный элемент в качестве поворота, в то время как другие используют стратегию случайного отбора для поворота.
def quicksort(a, arr_type):
def do_partition(a, arr_type, start, end):
# Performs the partitioning of the subarray a[start:end]
# We choose the last element as the pivot
pivot_idx = end
pivot = a[pivot_idx]
# Keep an index for the first partition
# subarray (elements lesser than the pivot element)
idx = start - 1
def increment_and_swap(j):
nonlocal idx
idx += 1
a[idx], a[j] = a[j], a[idx]
[increment_and_swap(j) for j in range(start, end) if a[j] < pivot]
# Finally, we need to swap the pivot (a[end] with a[idx+1])
# since we have reached the position of the pivot in the actual
# sorted array
a[idx+1], a[end] = a[end], a[idx+1]
# Return the final updated position of the pivot
# after partitioning
return idx+1
def quicksort_helper(a, arr_type, start, end):
if start < end:
# Do the partitioning first and then go via
# a top down divide and conquer, as opposed
# to the bottom up mergesort
pivot_idx = do_partition(a, arr_type, start, end)
quicksort_helper(a, arr_type, start, pivot_idx-1)
quicksort_helper(a, arr_type, pivot_idx+1, end)
quicksort_helper(a, arr_type, 0, len(a)-1)
Здесь QuickSort_Helper Метод делает шаг подхода Divide и Conquer, а do_partition Способ разбивает массив вокруг поворота и возвращает положение поворота, вокруг которого мы продолжаем рекурсивно разделить подрасход до и после поворота, пока весь массив не будет отсортирован.
Тестовый случай :
b = array.array('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
print('Before QuickSort ->', b)
quicksort(b, 'i')
print('After QuickSort ->', b)
Выход:
Before QuickSort -> array('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
After QuickSort -> array('i', [1, 1, 2, 3, 3, 4, 5, 6, 7, 12])
Заключение
В этой статье мы проходили через алгоритмы Mergeort и Quicksort для выполнения сортировки на массивах Python, набираем понимание того, как мы можем использовать разделить и завоевать в сверху вниз, а также в снизу мода. Мы также кратко посмотрели на родных отсортировано () Способ того, что язык предоставляет сортировка по темпам.