Recursive Selection Sort python

So. Do you understand the problem?

Let's look at what you were asked to do:

extract the maximum element, instead of the minimum, only to .append(...) it on to a recursively sorted sublist.

So, we do the following things:

1) Extract the maximum element. Do you understand what "extract" means here? Do you know how to find the maximum element?

2) Recursively sort the sublist. Here, "the sublist" consists of everything else after we extract the maximum element. Do you know how recursion works? You just call your sort function again with the sublist, relying on it to do the sorting. After all, the purpose of your function is to sort lists, so this is supposed to work, right? :)

3) .append() the maximum element onto the result of sorting the sublist. This should not require any explanation.

Of course, we need a base case for the recursion. When do we have a base case? When we can't follow the steps exactly as written. When does that happen? Well, why would it happen? Answer: we can't extract the maximum element if there are no elements, because then there is no maximum element to extract.

Thus, at the beginning of the function we check if we were passed an empty list. If we were, we just return an empty list, because sorting an empty list results in an empty list. (Do you see why?) Otherwise, we go through the other steps.

the sort method should do what you want. If you want the reverse, just use list.reverse()

If your job is to make your own sort method, that can be done.

Maybe try something like this:

def sort(l):
    li=l[:]                                        #to make new copy
    newlist = []                                   #sorted list will be stored here
    while len(li) != 0:                            #while there is stuff to be sorted
        bestindex = -1                             #the index of the highest element
        bestchar = -1                              #the ord value of the highest character
        bestcharrep = -1                           #a string representation of the best character
        i = 0
        for v in li:
            if ord(v) < bestchar or bestchar == -1:#check if string is lower than old best
                bestindex = i                      #Update best records
                bestchar = ord(v)
                bestcharrep = v
            i += 1
        del li[bestindex]                          #delete retrieved element from list
        newlist.append(bestcharrep)                #add element to new list
    return newlist                                 #return the sorted list

You need to remove the current max from the list and then recurse with the now shorter list. Again remove the largest until the list is empty, percolate back out appending the items from smallest to largest to the growing list. If reverse is True we remove the smallest item so when the list is reassembled it is in reverse order.:

def selsort(l,reverse=False):
    """
    sorts l in-place.
    PRE: l is a list.
    POST: l is a sorted list with the same elements; no return value.
    """      
    if len(l) <= 1: return # One left  
    x = min(l) if reverse else max(l) 
    l.remove(x) # Remove largest or smallest for later
    selsort(l,reverse) # keep going until list is used up
    l.append(x) # put this back in order as we percolate