合并排序二维数组

Question

I'm stuck again on trying to make this merge sort work. Currently, I have a 2d array with a Unix timecode(fig 1) and merge sorting using (fig 2) I am trying to check the first value in each array ie array[x][0] and then move the whole array depending on array[x][0] value, however, the merge sort creates duplicates of data and deletes other data (fig 3) my question is what am I doing wrong? I know it's the merge sort but cant see the fix.

fig 1

[[1422403200        100]
 [1462834800        150]
 [1458000000         25]
 [1540681200        150]
 [1498863600        300]
 [1540771200        100]
 [1540771200        100]
 [1540771200        100]
 [1540771200        100]
 [1540771200        100]]

fig 2

import numpy as np


def sort(data):
    if len(data) > 1:
        Mid = len(data) // 2
        l = data[:Mid]
        r = data[Mid:]
        sort(l)
        sort(r)

        z = 0
        x = 0
        c = 0

        while z < len(l) and x < len(r):
            if l[z][0] < r[x][0]:
                data[c] = l[z]
                z += 1
            else:
                data[c] = r[x]
                x += 1
            c += 1

        while z < len(l):
            data[c] = l[z]
            z += 1
            c += 1

        while x < len(r):
            data[c] = r[x]
            x += 1
            c += 1
        print(data, 'done')
unixdate = [1422403200, 1462834800, 1458000000, 1540681200, 1498863600, 1540771200, 1540771200,1540771200, 1540771200, 1540771200]
price=[100, 150, 25, 150, 300, 100, 100, 100, 100, 100]
array = np.column_stack((unixdate, price))
sort(array)
print(array, 'sorted')

fig 3

[[1422403200        100]
 [1458000000         25]
 [1458000000         25]
 [1498863600        300]
 [1498863600        300]
 [1540771200        100]
 [1540771200        100]
 [1540771200        100]
 [1540771200        100]
 [1540771200        100]] 

Answer 1

I couldn't spot any mistake in your code.

I have tried your code and I can tell that the problem does not happen, at least with regular Python lists: The function doesn't change the number of occurrence of any element in the list.

data = [
 [1422403200, 100],
 [1462834800, 150],
 [1458000000,  25],
 [1540681200, 150],
 [1498863600, 300],
 [1540771200, 100],
 [1540771200, 100],
 [1540771200, 100],
 [1540771200, 100],
 [1540771200, 100],
]

sort(data)

from pprint import pprint
pprint(data)

Output:

[[1422403200, 100],
 [1458000000, 25],
 [1462834800, 150],
 [1498863600, 300],
 [1540681200, 150],
 [1540771200, 100],
 [1540771200, 100],
 [1540771200, 100],
 [1540771200, 100],
 [1540771200, 100]]

---

Edit , taking into account the numpy context and the use of np.column_stack .

-I expect what happens there is that np.column_stack actually creates a view mapping over the two arrays. To get a real array rather than a link to your existing arrays, you should copy that array:-

 
 
 
  
  array = np.column_stack((unixdate, price)).copy()
 
  

---

Edit 2 , taking into account the numpy context

This behavior has actually nothing to do with np.column_stack ; np.column_stack already performs a copy.

The reason your code doesn't work is because slicing behaves differently with numpy than with python. Slicing create a view of the array which maps indexes.

The erroneous lines are:

 l = data[:Mid] r = data[Mid:] 

Since l and r just map to two pieces of the memory held by data , they are modified when data is. This is why the lines data[c] = l[z] and data[c] = r[x] overwrite values and create copies when moving values.

If data is a numpy array, we want l and r to be copies of data, not just views. This can be achieved using the copy method.

 l = data[:Mid] r = data[Mid:] if isinstance(data, np.ndarray): l = l.copy() r = r.copy() 

This way, I tested, the copy works.

---

Note

If you wanted to sort the data using python lists rather than numpy arrays, the equivalent of np.column_stack in vanilla python is zip :

 z = zip([10, 20, 30, 40], [100, 200, 300, 400], [1000, 2000, 3000, 4000]) z # <zip at 0x7f6ef80ce8c8> # `zip` creates an iterator, which is ready to give us our entries. # Iterators can only be walked once, which is not the case of lists. list(z) # [(10, 100, 1000), (20, 200, 2000), (30, 300, 3000), (40, 400, 4000)] 

The entries are (non-mutable) tuples. If you need the entries to be editable, map list on them:

 z = zip([10, 20, 30, 40], [100, 200, 300, 400], [1000, 2000, 3000, 4000]) li = list(map(list, z)) # [[10, 100, 1000], [20, 200, 2000], [30, 300, 3000], [40, 400, 4000]] 

To transpose a matrix, use zip(*matrix) :

 def transpose(matrix): return list(map(list, zip(*matrix))) transpose(l) # [[10, 20, 30, 40], [100, 200, 300, 400], [1000, 2000, 3000, 4000]] 

You can also sort a python list li using li.sort() , or sort any iterator (lists are iterators), using sorted(li) .

Here, I would use (tested):

 sorted(zip(unixdate, price))