Breaking News: Grepper is joining You.com. Read the official announcement!

sorting algorithms

Paul Negedu answered on June 19, 2023 Popularity 9/10 Helpfulness 1/10

answer sorting algorithms

sorting algorithms

Comment

Implement, time & rank 13 sorting algorithms in python3
https://github.com/paulnegz/sorts-py/

def quick_sort(array :list)->list:
    def _quick_sort(array :list)->list:
        if len(array)<=1: return array
        
        pivot, is_bigger = array.pop(), lambda x: x>pivot
        left_partition = _quick_sort([x for x in array if not is_bigger(x)])
        right_partition = _quick_sort([x for x in array if is_bigger(x)])
        return [*left_partition, pivot, *right_partition]
    return _quick_sort(array)

def bubble_sort(array :list)->list:
    for y in range(1, len(array)):
        swap: bool = False
        for x in range(1,len(array)-(y-1)):
            if array[x]<array[x-1]:
                array[x],array[x-1], swap = array[x-1],array[x], True
        if not swap: break
    return array 
  
  def radix_sort(array :list)->list:
    base, max_length = 10, len(str(max(array)))
    for n in range(max_length):
        bucket=[[] for _ in range(base)]
        for item in array: bucket[item//base**n%base].append(item)
        flat_map = lambda arr: reduce(lambda acc, curr: [*acc,*curr], arr)
        array = flat_map(bucket)
    return array
  
  def selection_sort(array :list)->list:
    for idx_y, _ in enumerate(array):
        min_idx = idx_y
        for idx in range(idx_y,len(array)):
            if array[idx] < array[min_idx]: min_idx = idx
        array[min_idx], array[idx_y] = array[idx_y], array[min_idx]
    return array
  
  def _shell_sort(array: list)->list:
    LENGTH, gap= len(array), len(array)//2
    while gap>0:
        for j in range(gap, LENGTH):
            i=j-gap 
            while i>=0:
                if array[i+gap]>array[i]: break
                else: array[i+gap],array[i]=array[i],array[i+gap]
                i=i-gap 
        gap=gap//2
    return array
  
  def bucket_sort(array :list)->list:
    BUCKET_SIZE = ceil(len(array)**(3/4))
    min_val, max_val = min(array), max(array)

    RANGE = (max_val-min_val+1)/BUCKET_SIZE
    bucket = [[] for _ in range(BUCKET_SIZE)]
    
    get_idx = lambda num: int((num-min_val)/RANGE)
    for num in array: bucket[get_idx(num)].append(num)
    for x in bucket: _insertion_sort(x)
    flat_map = lambda arr: reduce(lambda acc, curr: [*acc,*curr], arr)
    return flat_map(bucket)

Popularity 9/10 Helpfulness 1/10 Language python

Source: Grepper

Tags: sorting whatever

Link to this answer
Share Copy Link

Contributed on Jun 19 2023

Paul Negedu

0 Answers Avg Quality 2/10

sorting algorithms

Contents

More Related Answers

sorting algorithms

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.