What is the meaning of k = k + 1? Is there any recommendations for sorting practical problems with solutions?

Question

I understand most of the parts of the implementation of the merge sort. But I am kind of confused about the k = k + 1 under the second and third while loop. I thought the k is going to update to 0 again whatever we do k = k + 1 or not. But the result would be different after I commented the k = k + 1. Could someone explain that to me?

And is there recommendations for me to find some practical sorting problems online(with solutions)?

def mergeSort(alist):
    print("Splitting ",alist)
    if len(alist)>1:
        mid = len(alist)//2
        lefthalf = alist[:mid]
        righthalf = alist[mid:]

        mergeSort(lefthalf)
        mergeSort(righthalf)

        i=0
        j=0
        k=0
        while i < len(lefthalf) and j < len(righthalf):
            if lefthalf[i] < righthalf[j]:
                alist[k]=lefthalf[i]
                i=i+1
            else:
                alist[k]=righthalf[j]
                j=j+1
            k=k+1

        while i < len(lefthalf):
            alist[k]=lefthalf[i]
            i=i+1
            k=k+1## what is the meaning of k += 1?
            # if we don't have k += 1 then the result will be
            #Merging  [0, 1, 2, 17, 26, 54, 55, 2, 0, 93, 2, 0]
            #[0, 1, 2, 17, 26, 54, 55, 2, 0, 93, 2, 0]

        while j < len(righthalf):
            alist[k]=righthalf[j]
            j=j+1
            k=k+1
    print("Merging ",alist)

alist = [54,26,93,17,77,31,44,55,20, 1, 2, 0]
mergeSort(alist)
print(alist)

nevets1219 · Accepted Answer · 2019-05-14T00:58:49.833

1

i represents the current position in the left half
j represents the current position in the right half
k represents the current position in the "merged" array

The first while continues until one of the index (i and j) has passes the length of the respective array.

The 2nd while and 3rd while behave the same - copy the remaining items in the halves into the "merged". One of the halves is already empty.

Increments to k has the same meaning in all 3 whiles you take an element from one of the halves and put it in and move on to the next index.

I'm not sure what's popular these days but on LeetCode there are a bunch of problems tagged with "sort" - many of them should have solutions as well.

Here's some information regarding the return values (not relevant here) and passing by reference or value (relevant):

I'd check out more resources if you are confused about the topic.

edited May 14 '19 at 00:58

answered May 14 '19 at 00:08

nevets1219

7,692
4
32
47

1

hackerrank.com and codingame.com can also provide you some various exercises, including merge sort. – Baptiste Merliot May 14 '19 at 00:16
Thank you. But I am a little bit confused how does it return back the longer halve after we split it into several halves? – Molly May 14 '19 at 00:42
Added clarification regarding your question - basically the `alist` is being updated instead of being returned. – nevets1219 May 14 '19 at 01:00
On a related note, some sorts can be done "in place" - see https://en.wikipedia.org/wiki/In-place_algorithm – nevets1219 May 14 '19 at 01:02
If you are still learning, debugging into the code can help you see what's happening line by line. – nevets1219 May 14 '19 at 01:05
Thank you guys for the help!! I will check it out. – Molly May 14 '19 at 02:15

What is the meaning of k = k + 1? Is there any recommendations for sorting practical problems with solutions?

1 Answers1