Сортировка числовых списков в Python от меньшего к большему
Основные способы сортировки чисел в Python
Наиболее эффективное решение
Для сортировки чисел по возрастанию в Python рекомендуется использовать встроенную функцию sorted() или метод list.sort(). Эти методы реализуют алгоритм Timsort, который работает за O(n log n) в худшем случае и является устойчивым. sorted() возвращает новый отсортированный список, а list.sort() изменяет исходный список на месте.
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # [1, 1, 2, 3, 4, 5, 6, 9]Python sort lambda (сортировка с lambda в python)
[1, 1, 2, 3, 4, 5, 6, 9]
Python сортировка по значению (сортировка по значению в python)
numbers.sort()
print(numbers) # [1, 1, 2, 3, 4, 5, 6, 9]Sorted values python (сортировка значений в python (sorted))
[1, 1, 2, 3, 4, 5, 6, 9]
Python числа в порядке возрастания (сортировка чисел по возрастанию в python)
Как отсортировать числа без использования встроенных функций?
Если требуется реализовать сортировку вручную, можно применить классические алгоритмы. Ниже приведён пример сортировки пузырьком.
def bubble_sort(arr):
n = len(arr)
for i in range(n):
swapped = False
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
swapped = True
if not swapped:
break
return arr
nums = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(nums)
print(nums)[11, 12, 22, 25, 34, 64, 90]
Возможные проблемы:
- Пузырьковая сортировка имеет сложность O(n^2), что делает её непригодной для больших массивов.
- Если не использовать флаг
swapped, алгоритм будет выполнять лишние проходы даже для уже отсортированного массива. - Изменение исходного списка происходит на месте, что может быть нежелательно.
Как отсортировать числа с помощью сортировки выбором?
Сортировка выбором последовательно находит минимальный элемент и перемещает его в начало списка.
def selection_sort(arr):
for i in range(len(arr)):
min_idx = i
for j in range(i + 1, len(arr)):
if arr[j] < arr[min_idx]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
return arr
nums = [29, 10, 14, 37, 13]
selection_sort(nums)
print(nums)[10, 13, 14, 29, 37]
Типичные ошибки:
- Неправильное обновление индекса минимального элемента приводит к пропуску элементов.
- Алгоритм также имеет квадратичную сложность и не подходит для больших данных.
Как использовать сортировку вставками для чисел?
Сортировка вставками строит итоговый список, вставляя каждый следующий элемент на своё место в уже отсортированной части.
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr
nums = [12, 11, 13, 5, 6]
insertion_sort(nums)
print(nums)[5, 6, 11, 12, 13]
Замечания:
Сортировка вставками эффективна для небольших массивов и для почти отсортированных данных, но в общем случае имеет сложность O(n^2).
Как отсортировать числа с помощью параметра key?
Встроенные функции позволяют задать ключ сортировки, например, по модулю числа или по другому критерию, сохраняя порядок возрастания.
numbers = [-5, 3, -2, 7, -1]
sorted_by_abs = sorted(numbers, key=abs)
print(sorted_by_abs) # [-1, -2, 3, -5, 7] - по модулю[-1, -2, 3, -5, 7]
Как отсортировать числа в обратном порядке (по убыванию)?
Хотя вопрос о возрастании, часто требуется обратная сортировка. Параметр reverse=True меняет направление.
nums = [4, 2, 9, 1]
nums.sort(reverse=True)
print(nums) # [9, 4, 2, 1][9, 4, 2, 1]
Какие проблемы возникают при сортировке смешанных типов данных?
Попытка отсортировать список, содержащий числа и строки, вызовет ошибку TypeError, так как Python не может сравнить разные типы.
mixed = [1, '2', 3]
# sorted(mixed) # TypeError: '<' not supported between instances of 'str' and 'int'TypeError: '<' not supported between instances of 'str' and 'int'
Решение: предварительно привести все элементы к одному типу или отфильтровать только числа.
Расширенные примеры сортировки чисел
Сортировка с использованием алгоритма слияния
Реализация сортировки слиянием, которая гарантирует O(n log n) и является устойчивой.
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
nums = [38, 27, 43, 3, 9, 82, 10]
print(merge_sort(nums))[3, 9, 10, 27, 38, 43, 82]
Быстрая сортировка (quicksort) с выбором опорного элемента
def quicksort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quicksort(left) + middle + quicksort(right)
nums = [3, 6, 8, 10, 1, 2, 1]
print(quicksort(nums))[1, 1, 2, 3, 6, 8, 10]
Сортировка чисел с плавающей точкой с учётом точности
floats = [0.1, 0.2, 0.05, 0.01]
sorted_floats = sorted(floats)
print(sorted_floats)[0.01, 0.05, 0.1, 0.2]
При работе с числами с плавающей точкой из-за представления в памяти могут возникать неожиданные сравнения, но встроенная сортировка справляется корректно.
Сортировка больших данных с использованием key и lambda
data = [{'name': 'Alice', 'score': 95}, {'name': 'Bob', 'score': 87}, {'name': 'Charlie', 'score': 95}]
sorted_by_score = sorted(data, key=lambda x: x['score'])
print(sorted_by_score)[{'name': 'Bob', 'score': 87}, {'name': 'Alice', 'score': 95}, {'name': 'Charlie', 'score': 95}]Сортировка по числовому полю словаря. Для устойчивости сохраняется порядок элементов с одинаковыми ключами.
Сортировка списка кортежей чисел по возрастанию второго элемента
pairs = [(1, 3), (2, 2), (4, 1)]
sorted_pairs = sorted(pairs, key=lambda x: x[1])
print(sorted_pairs)[(4, 1), (2, 2), (1, 3)]
Неустойчивая сортировка: пример с сортировкой выбором
items = [(1, 'a'), (2, 'b'), (1, 'c')]
# Сортировка по первому элементу (неустойчивая)
def unstable_sort(arr):
for i in range(len(arr)):
min_idx = i
for j in range(i+1, len(arr)):
if arr[j][0] < arr[min_idx][0]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
return arr
result = unstable_sort(items.copy())
print(result) # Порядок (1,'a') и (1,'c') может измениться[(1, 'c'), (1, 'a'), (2, 'b')]
В отличие от устойчивой сортировки (например, Timsort), выборка не сохраняет первоначальный порядок равных элементов.