Implement the Quicksort Algorithm - Implement the Quicksort Algorithm

Tell us what’s happening:

Hello, I am currently trying to solve the quick sort algorithm , but I have come across an IndexError but I don’t know why it occurred and what I did wrong? I marked some of the lines where the error occurred with an ‘x’ :slight_smile:

Your code so far

def quick_sort(int_list):
    if not int_list:
        return []
    sorted_list = []
    pivot_value = int_list[0]

    pivot_part = []
    greater_part = []
    lesser_part = []
    for number in int_list:
        if number > pivot_value:
            greater_part.append(number)
        elif number == pivot_value:
            pivot_part.append(number)
        else:
            lesser_part.append(number)

    greater_part_index = 0
    lesser_part_index = 0
    pivot_part_index = 0

#Sort the lesser part
    lesser_midpart = len(lesser_part) // 2
    right_lesser_part = lesser_part[lesser_midpart:]
    left_lesser_part = lesser_part[:lesser_midpart]
    quick_sort(right_lesser_part)
    quick_sort(left_lesser_part)
    lesser_sorted_list = []
    i = 0
    j = 0
    lesser_sorted_index = 0
    
    while i < len(left_lesser_part) and j < len(right_lesser_part):
        
        if right_lesser_part[j] <= left_lesser_part[i]:
x            lesser_sorted_list[lesser_sorted_index] = (right_lesser_part[j])
            j += 1
        else:
x            lesser_sorted_list[lesser_sorted_index] =(left_lesser_part[i])
            i += 1
        lesser_sorted_index += 1
    
    while i < len(left_lesser_part):
 x       lesser_sorted_list[lesser_sorted_index] = left_lesser_part[i]
        i += 1
        sorted_index += 1
    
    while j < len(right_lesser_part):
  x      lesser_sorted_list[lesser_sorted_index] = right_lesser_part[j]
        j += 1
        sorted_index += 1

    lesser_sorted_list.extend(left_lesser_part[i:])
    lesser_sorted_list.extend(right_lesser_part[j:])

#Sort the greater part
    greater_midpart = len(greater_part) // 2
    right_greater_part = greater_part[greater_midpart:]
    left_greater_part = greater_part[:greater_midpart]
    quick_sort(right_greater_part)
    quick_sort(left_greater_part)
    greater_sorted_list = []
    f = 0
    t = 0
    greater_sorted_index = 0
    while f < len(left_greater_part) and t < len(right_greater_part):
        if right_greater_part[t] <= left_greater_part[f]:
            greater_sorted_list[greater_sorted_index] =(right_greater_part[t])
            t += 1
        else:
            greater_sorted_list[greater_sorted_index] =(left_greater_part[f])
            f += 1
        greater_sorted_index += 1
    
    while f < len(left_greater_part):
        greater_sorted_list[greater_sorted_index] = left_greater_part[i]
        f += 1
        sorted_index += 1
    
    while t < len(right_greater_part):
        greater_sorted_list[greater_sorted_index] = right_greater_part[j]
        t += 1
        sorted_index += 1
        
    greater_sorted_list.extend(left_greater_part[f:])
    greater_sorted_list.extend(right_greater_part[t:])
    
    sorted_list.extend(lesser_sorted_list)
    sorted_list.extend(pivot_part)
    sorted_list.extend(greater_sorted_list)
    return sorted_list
    


numbers = [83, 4, 24, 2]
print('Unsorted list of numbers:')
print(numbers)
print('Sorted list of numbers:')
print(quick_sort(numbers))

Your browser information:

User Agent is: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15

Challenge Information:

Implement the Quicksort Algorithm - Implement the Quicksort Algorithm

Hi @lucca.homann ,

Try using this Python Code Visualizer to step through your code and see what it’s doing.

Happy coding!

Thank you so much, I really complicated things way too much :joy: