如何在数组中查找最小元素时排除-1 sentinel值，java

我试图在一个由25个元素组成的数组中找到最小的元素，当用户输入-1时，这些元素将被用户读取并停止

import java.util.*;
public class LabSheet4{
public static void main (String[] args){
Scanner read = new Scanner (System.in);

double scores[] = new double[25];
int minIndex=0, i =0, sentinel=0;


do{
scores[i] = read.nextDouble();
if(scores[i]==-1)
sentinel=-1;
i++;}while(sentinel!=-1);

for(int k=0;k<scores.length;k++)
if(scores[minIndex] > scores[k] && scores[minIndex]>0)
minIndex = k;
lowestScore = scores[minIndex];}}

import java.util.*；
公共类标签4{
公共静态void main（字符串[]args）{
扫描仪读取=新扫描仪（System.in）；
双倍分数[]=新的双倍分数[25]；
int minIndex=0，i=0，sentinel=0；
做{
分数[i]=read.nextDouble（）；
如果（分数[i]=-1）
哨兵=-1；
i++；}while（哨兵！=-1）；
对于（整数k=0；k分[k]&分[minIndex]>0）
minIndex=k；
最低分数=分数[minIndex]；}

---

如何排除-1

根本不要将-1存储在

分数中。

这样以后就不必排除它了

最重要的是， 它不像你存储的其他值那样是一个函数值， 但在您处理输入的方式中具有特殊技术含义的符号。 因此，它不属于

scores

数组

更改读取用户输入的循环， 以避免存储-1。 在存储之前检查输入， 如果为-1，则中断循环：

while (true) {
    double input = read.nextDouble();
    if (input == -1) {
        break;
    }
    scores[i++] = input;
}

顺便说一句，如果用户输入的26个值不是-1，会发生什么？ 程序将崩溃，因为

分数

只能存储25个值。 因此，您需要进一步的改进来防止这种情况发生。 例如，您可以将

用于
循环：

for (int i = 0; i < scores.length; i++) {
    double input = read.nextDouble();
    if (input == -1) {
        break;
    }
    scores[i] = input;
}

for（int i=0；i
根本不要在
分数中存储-1。
这样以后就不必排除它了

最重要的是，
它不像你存储的其他值那样是一个函数值，
但在您处理输入的方式中具有特殊技术含义的符号。
因此，它不属于
scores
数组

更改读取用户输入的循环，
以避免存储-1。
在存储之前检查输入，
如果为-1，则中断循环：

while (true) {
    double input = read.nextDouble();
    if (input == -1) {
        break;
    }
    scores[i++] = input;
}

顺便说一句，如果用户输入的26个值不是-1，会发生什么？
程序将崩溃，因为
分数
只能存储25个值。
因此，您需要进一步的改进来防止这种情况发生。
例如，您可以将
用于
循环：

for (int i = 0; i < scores.length; i++) {
    double input = read.nextDouble();
    if (input == -1) {
        break;
    }
    scores[i] = input;
}

for（int i=0；i
一种方法是，在您知道该值不是sentinel之前，不要将其放入列表中

另一种方法是，当您发现添加了哨兵时，不要增加计数器。请注意，这意味着您需要一个稍大一点的数组。
一种方法是在您知道该值不是sentinel之前，不要将其放入列表中

另一种方法是，当您发现添加了哨兵时，不要增加计数器。请注意，这意味着您需要一个稍大一点的阵列。
一种方法是不首先存储它，另一种修复方法是在这样的阵列上运行时忽略它

   for(int k=0;k<scores.length;k++)
        if(scores[minIndex] > scores[k] && scores[minIndex]>0 && scores[k] !=1)

for（int k=0；k分数[k]&分数[minIndex]>0&分数[k]！=1）
一种方法是首先不存储它，另一种修复方法是在这样的阵列上运行时忽略它

   for(int k=0;k<scores.length;k++)
        if(scores[minIndex] > scores[k] && scores[minIndex]>0 && scores[k] !=1)

for（int k=0；k分数[k]&分数[minIndex]>0&分数[k]！=1）
这类问题的一个常见习惯用法是使用
while
循环进行赋值和测试。大概

double scores[] = new double[25];
int i = 0;
double score;
while ((score = read.nextDouble()) != -1) {
    scores[i] = score;
    i++;
}

然后可以从
0
开始，从
1
迭代到
i
（因为
0
是初始值，
i
是元素计数）。像

int minIndex=0；
对于（int k=1；k分数[k]）{
minIndex=k；
}
}
双倍最低分数=分数[minIndex]；
这类问题的一个常见习惯用法是使用
while
循环进行赋值和测试。大概

double scores[] = new double[25];
int i = 0;
double score;
while ((score = read.nextDouble()) != -1) {
    scores[i] = score;
    i++;
}

然后可以从
0
开始，从
1
迭代到
i
（因为
0
是初始值，
i
是元素计数）。像

int minIndex=0；
对于（int k=1；k分数[k]）{
minIndex=k；
}
}
双倍最低分数=分数[minIndex]；
而不是

if(scores[i]==-1)
sentinel=-1;

使用

因此，您将
-1
替换为（到目前为止）最低的值-这没问题，不是吗？
而不是

if(scores[i]==-1)
sentinel=-1;

使用

因此，您将
-1
替换为（到目前为止）最低的值-这是正常的，不是吗