九. Sort 4 Sort Integers II

这道题不难，我只是想讨论一下，如何用mergesort的解法。因为该题不允许返回，所以所有的操作都应该直接建立在该数组上，不然就需要对该数组的指针进行修改（赋值操作都是都是对该数组引用的操作，而不能修改存在内存里的值）
可惜python3 没有指针
就比如如下代码：

class Solution:
    """
    @param A: an integer array
    @return: nothing
    """
    def sortIntegers2(self, A):
        # write your code here
        def merge_sort(A):
            if len(A) == 1 or not A:
                return A
                
            mid = len(A)//2
            A_1 = merge_sort(A[:mid])
            A_2 = merge_sort(A[mid:])
            
            if A_1 and A_2:
                i=0
                j=0
                sort = []
                while True:
                    if A_1[j] < A_2[i]:
                        sort.append(A_1[j])
                        j +=1
                    else:
                        sort.append(A_2[i])
                        i +=1
                    if j == len(A_1):
                        sort +=A_2[i:]
                        return sort
                    else:
                        if i == len(A_2):
                            sort +=A_1[j:]
                            return sort
                        else:
                            continue
            
            else:
                if A_2:
                    return A_2
                else:
                    return A_1
                
        A = merge_sort(A)

最后测试得到的结果是没有变化的原数组的值。可我在对sort输出测试时，却能得到一个正确排序的结果。

不知道是不是有这样一种方法解决这个问题？

附带heapsort的解决方案，不过效率太低了…………

class Solution:
    """
    @param A: an integer array
    @return: nothing
    """
    def sortIntegers2(self, A):
        # write your code here
        def heapfy(A, index, end):
            larger = index
            
            if index*2+1 < end and index*2+2 < end:
                if A[index*2+2] < A[index*2+1]:
                    larger = index*2+1
                else:
                    larger = index*2+2
            else:
                if index*2+1 < end:
                    larger = index*2+1
                else:
                    if index*2+2 < end:
                        larger = index*2+2
                    
            if A[index] < A[larger]:
                A[index], A[larger] = A[larger], A[index]
                heapfy(A, larger, end)
                
            if larger != index:
                heapfy(A, larger, end)
                    
        def maximum_heap(A):
            for index in range(len(A)-1,-1,-1):
                heapfy(A, index, len(A))
        
        maximum_heap(A)
        for index in range(len(A)-1,-1,-1):
            A[0],A[index] = A[index],A[0]
            heapfy(A,0,index)