Question

我有两个数组（不是ArrayLists）：

A: [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 0, 0, 0, 0, 0];
B: [50, 100, 150, 200, 250];

我需要创建一个while循环，将数组B中的值插入到数组A. 例如，如果position / index K = 5，则结果应为：

A: [0, 5, 10, 15, 20, 25, 50, 100, 150, 200, 250, 30, 35, 40, 45];

使得B []的内容在索引K处就地插入到A []中。这会将现有内容推送到右侧，并删除在数组范围之外推送的任何内容。

然后我需要使用do while循环打印出新的A值。

我需要使用2个循环完成所有操作：1 while loop用于替换，1 do While循环用于打印。即使没有必要，这些也是给我的条件。

在我的问题中，作业中提到的所有内容都是：根据索引为K的元素将数组B的所有元素嵌套在数组A中。

对不起，如果我不清楚，我开始学习编程5天前，我不太熟悉我应该提到的细节，也许我写的代码到现在可以帮助带来一些更多的背景（The第一个while循环是我尝试做我在这个帖子中要求的地方）：

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class Rainers {

    public static void main(String[] args) {

        int A[] = new int[15];
        int B[] = new int[5];
        for (int i = 10; i < A.length; i++) {
            A[i] = 0;
        }
        int K;
        Scanner sc = new Scanner(System.in);
        System.out.println("Name Lastname ID1 ID2");
        System.out.print("K=");

        if (sc.hasNextInt())
            K = sc.nextInt();
        else {
            System.out.println("input-output error");
            sc.close();
            return;
        }
        sc.close();

        if (K >= 0 && K <= 9) {
            for (int k = 0; k <= 9; ++k) {

                A[k] = k * K;
            }
            for (int k = 0; k <= 4; ++k) {

                B[k] = 10 * (k + 1) * K;

            }
        }
        else if (K < 0 || K > 9) {
            K = 5;
            Random diapazons = new Random();
            for (int c = 0; c < 10; ++c) {
                A[c] = diapazons.nextInt(50);
            }
            for (int c = 0; c < 5; ++c) {
                B[c] = diapazons.nextInt(100 - 50 + 1) + 50;
            }
        }
        sc.close();
        System.out.println("A: " + Arrays.toString(A));
        System.out.println("B: " + Arrays.toString(B));

        int count = K;

        while (count > K && count <= A.length) {
            int x = 0;
            x++;
            A[K] = B[x];
            count++;

        }

        System.out.println("A: " + Arrays.toString(A));
    }
}

提前感谢您的时间，我真的很感激。

Answer 1

我在堆栈溢出中也是 noobie 。首先，我建议您使用ArrayList，因为一旦学会它们就会更灵活。它不是一个干净或优化的代码，但是，尝试将以下算法添加到您的代码中。 我是一个努力活跃，学习并参与堆栈溢出的noobie。此代码可能包含错误的错误。但我希望我帮助解释了alogirthm的方法。

}

Answer 2

您的代码

int count = K;

while (count > K && count <= A.length) {
    int x = 0;
    x++;
    A[K] = B[x];
    count++;
}

有一些问题：

它没有任何效果，因为您设置count = K然后给出条件count > K。
条件count <= A.length会导致AIOOBE，因为最后一个元素位于A.length - 1。
您希望从头开始访问B，但在第一次访问它之前会增加其值。
由于您也在迭代B，因此循环中需要一个停止条件才能尝试访问大于它的索引。
您将B的值设置为A，但同时您正在丢失A中的值，因为它们被覆盖了。在覆盖之前，您需要将值存储在正确的位置。

一旦你解决了这些错误，你就可以解决问题。您可以尝试解决这些问题来编辑问题。

Answer 3

必须先移动A中的元素，然后才能插入B中的元素。首先从数组后面移动所有值，以避免丢失任何元素。将元素向右移动一步时，元素的移动应如下所示：

 1. [5, 10, 15]
 2. [5, 10, 15] 15
 3. [5, 10, 10] 15
 4. [5, 5, 10] 15
 5. [2, 5, 10] 15

元素15将从数组中删除，但5和10仍将保留在数组中。然后可以为5的旧位置分配新值，例如， 2。

从数组的最后一个索引迭代并移动元素，以便B的元素可以适合。但是，不是上面的一步，而是将元素移动B的长度。达到索引K时停止迭代，因为不会插入或移动更多元素。下面的java代码移动数组A的元素，并从B分配值。第一个if语句避免索引超出范围。第二个if语句检查是否应将B中的元素插入A。

 int idxA = A.length - 1;
 int idxB = B.length - 1;
 while(idxA >= K){
    if (idxA + B.length < A.length)
        A[idxA + B.length] =  A[idxA];

    if (idxA < B.length + K){
        A[idxA] = B[idxB];
        idxB--;
    }

    idxA--;
 }

如果您不确定代码的工作原理，请使用笔和纸在代码的每一步写入每个数组的当前状态。

Answer 4

我按照输出修改了代码。

    // while (count > K && count <= A.length) {
    // int x = 0;
    // x++;
    // A[K] = B[x];
    // count++;
    //
    // }

更改为新代码

    System.arraycopy(A, K, A, K + B.length, B.length);
    System.arraycopy(B, 0, A, K, B.length);

Java /使用while循环替换简单数组中的元素

4 个答案: