Question

下面是一个程序，它为n*log(n)计算数组中的求反数-在这方面，没有什么比这更好的了，但是会浪费很多内存。

该程序中是否有任何方法可以优化内存使用？

import java.lang.Integer.min
var inversions: Long = 0

fun main(){
    val length = readLine()!!.toInt()
    val inputArray = readLine()!!.split(' ').map(String::toInt).toMutableList()
    mergeSort(inputArray, 0, length - 1)
    println(inversions)
}


fun merge(array: MutableList<Int>, left: Int, center: Int, right: Int){
    val amount = right - left + 1
    val tempArray = MutableList(amount) {0}
    var i = left ; var j = center + 1 ; var t = 0
    while (i <= center && j <= right){
        tempArray[t] = min(array[i], array[j])
        if(min(array[i], array[j]) == array[i]) i +=1
        else{
            j += 1
            inversions += center + 1 - i
        }
        t += 1
    }
    if(i > center)
        while (j <= right){
            tempArray[t] = array[j]
            j += 1; t += 1
        }
    else
        while (i <= center){
            tempArray[t] = array[i]
            i += 1; t += 1
        }
    t = 0
    for(index in left..right){
        array[index] = tempArray[t]
        t += 1
    }
}

fun mergeSort(array: MutableList<Int>, left: Int, right: Int){
    if (left < right){
        val center: Int = left + (right - left) / 2
        mergeSort(array, left, center)
        mergeSort(array, center + 1, right)
        merge(array, left, center, right)
    }
}

Answer 1

（这可能没有一个完整的答案，所以我觉得在这里发表初步想法是有道理的：-）

您可能要做的一件事是重用单个tempArray，而不是在每次调用merge()时都创建一个新的。初始化需要花更多的精力，但这应该避免大量的临时对象。

（这应该是安全的，因为merge()不会递归。您可以在main()中创建它，并将其作为参数传递到mergeSort()中，然后从那里传递到{{1} }。或者您可以将其设置为“静态”，即将其放在同伴对象或顶级字段中。尽管后一种情况会阻止它在多个线程中被调用；但是要解决此问题，请将其保存在{{1}中}。

Kotlin（JVM）中的内存使用优化/管理

1 个答案: