在没有内置排序的情况下从给定列表中排序数字列表，如果第一个数字大于第二个数字则复制它们交换它们

Question

I am tring to implement a function in a way that it does basically the same thing as sorted(lst) without using sorted(lst) or var = lst.copy() but I just can't figure it out how to work it that way and following exactly the way as it is written in the pseudo code.

Can someone please help me?

My assesment is:

Below is the pseudocode of a sorting algorithm:

1. Starting from the beginning of a list, compare each element with its next neighbor.
2. If the element is larger than its next neighbour, change them places.
3. Go through the list to the end.
4. If there have been any mix-ups at step 2,go to step 1

my code right now:

def my_sort(lst):
    lst_sorted = []
    lst2 = lst.copy()
    compare = True
    while compare:
        compare = False
        num = lst2[0]
        if num not in lst_sorted:
            try:
                for x in lst2:
                    if x < num:
                        x, num = num, x
                        lst_sorted.append(num)
                    elif num < x:
                        compare = True
        else:
            compare = True
    return lst_sorted

the test code that my professor gave me:

def test_my_sort():
    lst_test = random.choices(range(-99, 100), k=6)
    lst_copy = lst_test.copy()
    lst_output = my_sort(lst_test)

    assert lst_copy == lst_test, "Error: my_sort (lst) changes the contents of list lst"
    assert lst_output == sorted(lst_test), \
        f"Error: my_sort ({lst_test}) returns {lst_output} instead of {sorted (lst_test)}"

if __name__ == '__main__':
    try:
        test_my_sort()
        print("Your my_sort () function works fine!")

Answer 1

Straightforward solution

Following your intention of using a flag compare and the exact assesment rules, here is a step by step explanation:

def my_sort(lst):
    # We copy the list so that the changes are not made in the original variable.
    # We will modify lst2 from now.
    lst2 = lst.copy()
    compare = True
    while compare is True:
        # compare will remain False as long as there is no swapping
        compare=False
        # We walk the list index by index, excepted the last one
        # so we don't get an index error from the last "index+1"
        for i in range(len(lst2)-1):
            # If the first is greater than the second...
            if lst2[i]>lst2[i+1]:
                # We swap
                bump = lst2[i]
                lst2[i]=lst2[i+1]
                lst2[i+1]= bump
                # and set compare to True to ask for another iteration of the while loop
                compare=True
    return lst2

Another way of swapping in Python

You can swap in one line:

for i in range(len(lst2)-1):
    if lst2[i]>lst2[i+1]:
       lst2[i], lst2[i+1] = lst2[i+1], lst2[i]
       compare=True

Optimizing Bubble sort

This sorting algorithm is called Bubble Sort .

There is an optimization based on the observation that the largest value is always carried to the end slot in a single iteration. Therefore, in the worst case scenario, you can avoid (n-1)**2 indexings by stopping one index earlier at each iteration.

Here is an adapted implementation:

def optimized_sort(lst):
    lst2 = lst.copy()
    compare = True
    #Creating a variable to store the iteration count
    n = 0
    while compare is True :
        compare=False
        # This time, we walk from index 0 to the last index minus the iteration count
        for i in range(len(lst2) - 1 - n):
            if lst2[i]>lst2[i+1]:
                lst2[i],lst2[i+1] = lst2[i+1], lst2[i]
                compare=True
        # We increment the iteration count
        n += 1
    return lst2

As you can see, the optimized one is indeed a bit more performing.

Of course, this algorithm remains a poorly performing one and mainly used for educational purpose.

Answer 2

I'm just learning python, but this works for me:

def my_sort(lst):
    randHolder = []
    for ele in range(len(lst)):
        mini = min(lst)
        giveIndex = lst.index(mini)
        popped = lst.pop(giveIndex)
        randHolder.append(popped)
    lst = randHolder
    return lst