Question

给定一个数组A，计算一个大小为n的新数组B. B [i] = min（0≤j≤i）A [j]。换句话说，B [i]应该将最小元素存储在A的子数组中，索引从0到i，包括0和i。

Input: A[7, 3, 4, 2, 15, 11, 16, 7, 18, 9, 11, 10]
Output: B[7, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2]

我试图创建最有效的算法来解决这个问题。我尝试使用伪代码。

minElement(A):
 B[n]; //empty array
  for(i = 0; i < A.length()-1; i++)
   if(A[i] < everything currently in B[])
    B[i] = A[i]

我很难尝试实现逻辑。

Answer 1

您需要一个变量currentMin来跟踪处理的输入数组部分中的最小值。

func calculate(nums:[Int]) -> [Int] {
    guard !nums.isEmpty else { return [] }
    var currentMin = nums[0]

    var output: [Int] = []
    for num in nums {
        currentMin = min(currentMin, num)
        output.append(currentMin)
    }

    return output
}

因此，在for循环中，您可以更新currentMin变量并将其值附加到输出。

提供的实现是在Swift中。

Answer 2

伪代码：

a<- input array;
b<- input array;
int m=a[1]
for 1 to a.length:
    m=min(m,a[i]);
    b[i]=m;
end;

在java中的实现：

public class demo {
public static void main(String[]args){
    int array[]={7, 3, 4, 2, 15, 11, 16, 7, 18, 9, 11, 10};
    int b[]=new int[array.length];
    int min=array[0];
    for (int i=0;i<array.length;i++){
        min=Math.min(min,array[i]);
        b[i]=min;
    }
    for (int i:b){
        System.out.print(i+" ");
    }
}
 }//prints  7 3 3 2 2 2 2 2 2 2 2 2

Answer 3

最 time 高效算法取决于语言。如果一种语言支持数组的内置高效min()函数，那么您可以使用预先计算的绝对最小变量来提前退出for循环。如果阵列高于某个最小长度，这将平均更快。

当然，您还需要一个滚动的最小变量。

<强>伪码：

minElement(A):
  B[n]; //empty array
  absoluteMin = min(A)
  rollingMin = A[0]
  for(i = 0; i < A.length()-1; i++)
    if(A[i] < rollingMin): rollingMin = A[i]
    B[i] = rollingMin
    if(rollingMin == absoluteMin): exit for

Python实现： ^{_{（有关计时的工作示例，请参阅here。）}}

A = [7, 3, 4, 2, 15, 11, 16, 7, 18, 9, 11, 10]
B = []
absoluteMin = min(A)
rollingMin = A[0]
for value in A:
    if value<rollingMin: rollingMin = value
    B.append(rollingMin)
    if rollingMin==absoluteMin: break
B += [absoluteMin]*(len(A)-len(B))

请注意，平均而言，随着数组变长，上面的代码与没有绝对最小部分的代码相比变得更快（如下所示）。您的样本数组实际上低于显示速度提升所需的最小长度。盈亏平衡点大约是这个长度的两倍。

A = [7, 3, 4, 2, 15, 11, 16, 7, 18, 9, 11, 10]
B = []
rollingMin = A[0]
for value in A:
    if value<rollingMin: rollingMin = value
    B.append(rollingMin)

找到数组中的最小值并最有效地存储在子数组中

3 个答案: