快速排序函数在被调用时返回 None

Question

I don't have the best grasp on how quicksort actually works, but I've been reading through other posts on stack overflow and watching videos to understand it. However, I was given some starter code a basic quicksort function and was tasked with the creating several lists both sorted and unsorted to be used with quicksort. However, I'm confused on what's actually being returned from this quicksort function. You don't personally have to explain the quicksort function to me - I'll work it out on my own, but I'd love help understanding how to actually call it.

from random import *

def quicksort( myList, first, last ):
    """ Sort the given list using the quicksort algorithm. Sorts the
        portion of the list between the first and last indices (inclusive).
    """
    # base case: done when the indices touch or overlap.
    if first >= last: return

    # recursive case: partition the myList and recurse on both sides
    split = partition( myList, first, last )
    quicksort( myList, first, split-1 )
    quicksort( myList, split+1, last )

def partition( myList, first, last ):
    """ Partition the given list into two parts. Smaller and larger values of pivot btwn them
        Partitions the portion of the list between the first and last indices (inclusive).
        Return the index of the pivot element.
    """

    lastSmall = first

    # Separate the list into "pivot, smalls, lastSmall, larges".
    for i in range( first+1, last+1 ): # first+1 ... last (inclusive)
        # if myList[i] is small, swap it onto the 'small' side.
        if myList[ i ] <= myList[ first ]:
            lastSmall = lastSmall + 1
            swap( myList, lastSmall, i )

    # Swap the pivot with lastSmall to get "smalls, pivot, larges".
    swap( myList, first, lastSmall )

    # Return the location of the pivot
    return lastSmall

def swap( myList, first, second ):
    """ Swap the items at the first and second indices in the given list.
        Assumes the indices are legal and occupied in the list.
    """
    tmp = myList[ first ]
    myList[ first ] = myList[ second ]
    myList[ second ] = tmp

def main():

    ''' task 1 '''
    # randomized list
    pt1 = [randint(0,10) for x in range(10)]
    print(pt1) # print randomized list before quicksort
    pt1 = quicksort(pt1,0,len(task1pt1)-1)   # this keeps giving me None
    print(pt1) # print pt1 list after quicksort
    pt2 = [x for x in range(10)]
    print(pt2)


main()

If I already have a list of numbers I want to be sorted, how am I actually supposed to call quicksort? Based on what I remember from class, my professor told us to use 0 as first and len(myList)-1 as last, but I don't understand what quicksort returns - is it a list? a singular number?

Answer 1

The quicksort function does not return the sorted list, but it returns None by default. However, it sorts the list by reference . The line pt1 = quicksort(...) is reassigning pt1 to None after it has been sorted. Thus the following would work:

pt1 = [randint(0,10) for x in range(10)]
print(pt1) 
quicksort(pt1,0,len(pt1)-1)   
print(pt1) # prints the sorted list