作业题要求用下面数组的每一位调用“find”和“find2”。但是，我被卡住了，因为我一开始不明白代码在做什么。摘自文本，该程序“测试 100 个元素的算法，其中包含 20% 的元素和 30% 的引用。”

{9,0,0,6,3,9,2,4,5,9,0,0,6,3,9,2,4,5,9,0,0,6,3,9,2,4,5} //A given set repeated 3 times

我被告知的是:

1. 我应该更改当前的 for 循环体
2. 我必须打印出搜索到的数组(搜索到的数字移到较早的位置)。

我要的是对以下内容的解释。然后我可以继续实际操作代码。

1. find2 到底在做什么？
2. 调用 find 和 find2 的 for 循环内部发生了什么？
3. 如何获得计数 4286 和 3903(如输出中所示)？ (这可能最终会在前面的一个问题中得到回答)

代码:

private static int x[]=new int[100];
public static void main(String[] args){
    Random r=new Random(17);

    //Making the array//
    for(int i=0;i<x.length;i++)x[i]=x.length-i;
    System.out.println(Arrays.toString(x));

    r.setSeed(17);
    // straight search
    for(int i=0;i<x.length*1;i++){
        float p=r.nextFloat();
        int j=(int)(p*79);
        if(p<0.3)find(j%20+1);
        else find(j+21);
    }
    System.out.println(n+" "+count);
    //identical but self-organizing
    r.setSeed(17);count=0;n=0;
    for(int i=0;i<x.length*1;i++){
        float p=r.nextFloat();
        int j=(int)(p*79);
        if(p<0.3)find2(j%20+1);
        else find2(j+21);
    }
    System.out.println(Arrays.toString(x));
    System.out.println(n+" "+count);
}

//Find
private static int find(int target){
    for(int i=0;i<x.length;i++)
        if(x[i]==target){
            count+=i;n++;
            return i;
        }
    return -1;
}
static int count=0,n=0;
static final int NEAR=100/10;

//Find2
private static int find2(int target){
    for (int i=0;i<x.length;i++)
        if(x[i]==target){
            count+=i; n++;
            if(i>NEAR){     //swap to NEAR
                x[i]=x[NEAR];
                x[NEAR]=target;
            } else if(i!=0){    //swap with predecessor
                x[i]=x[i-1];
                x[i-1]=target;
            }
            return i;
        }
    return -1;
}

输出:

[100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
100 4286
[99, 100, 97, 96, 98, 92, 93, 91, 94, 95, 5, 84, 56, 46, 86, 52, 83, 87, 49, 82, 3, 78, 45, 53, 44, 75, 74, 6, 2, 71, 85, 69, 18, 7, 19, 68, 64, 81, 62, 12, 88, 16, 4, 57, 90, 61, 55, 70, 63, 51, 50, 73, 48, 47, 1, 89, 79, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 65, 80, 17, 58, 15, 14, 13, 72, 11, 10, 9, 8, 67, 66, 54, 59, 77, 60, 76]
100 3903

非常感谢任何帮助。另外，如果我问这个问题的方式有任何问题，请告诉我，因为这是我的第一个问题。

编辑:我尝试了以下修改，输出发生了变化。但是在不了解代码的作用的情况下，我并不完全了解潜在的影响。

private static int y[]={9,0,0,6,3,9,2,4,5,9,0,0,6,3,9,2,4,5,9,0,0,6,3,9,2,4,5}; //placed right under x[]
for(int j=0;j<y.length;j++)find(y[j]); //for the 'straight search' for-loop body
for(int j=0;j<y.length;j++)find2(y[j]); //for the 'self-organizing' for-loop body

最佳答案

1。 find2 到底在做什么？
自组织算法试图以一种方式组织自己，使得更经常搜索的项目更靠近前面。这样，当搜索阵列时，可以在后续搜索中更快地找到更频繁的目标。例如，如果您在 i = 99 处搜索并找到 1，则将其移至 NEAR (10) 将使第二次检索速度提高 10 倍。但是，就我所见，创建排序数组来显示这一点的想法有点愚蠢。如果您已经有一个排序数组，比如在您的示例中是 1 - 100 降序，您可以只检查目标并拆分数组，或者直接将其作为 x[100-target] 提供，它确实会为您提供目标。如果是我，我会随机化元素，哦，好吧。

2。调用 find 和 find2 的 for 循环内部发生了什么？
这些只是生成*伪*随机数作为目标。它们是伪的，因此每次结果都是相同的，因为“随机”数字不是那么随机。它们也仅限于数据集，因为 nextFloat() 将返回一个介于 0.0 和 1.0 之间的数字 - p*79 只给出 79 的百分比，然后根据 p 计算出介于 1 和 100 之间的目标。

3。计数 4286 和 3903 是如何获得的？
这些计数试图向您表明您已经完成了您尝试的任务，即更快地找到数据。基本上 count 是一个累加器。每次在 i 处找到一个目标，就将 i 添加到计数中。如果在 i = 1、2 和 3 处找到三个元素，则计数将为 6。较大的元素显示已找到目标的所有索引的总和，但不允许它自行组织。较小的显示由于新组织，您能够改进搜索。如果没有获得性能，数字将是相同的。

您可以将目标存储在另一个数组中，然后查看特定目标被调用的频率，以关联您所看到的输出，乍一看它只是随机的。

关于java - 自组织搜索程序，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/20085016/