Question

我一直试图弄清楚我是否可以使用其他类型的数据结构来解决这个问题。我设法以某种方式解决它，但仍然缺乏很多高质量的代码。

前几天我接受采访时被问到：给定一个输入字符串，如：

String[] inputString = { "a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"};

将其转换为输出字符串：

String[] outputString = { "a1", "b1", "a2", "b2", "a3", "b3", "a4", "b4", "a5", "b5" };

我尝试了以下内容，到目前为止，我觉得这需要一些改进：

public class ArrayApp {
    public static void main(String[] args) {

        String[] inputString = { "a1", "a2", "a3", "a4", "a5", "b1", "b2",
                "b3", "b4", "b5" };
        // String[] outputString = { "a1", "b1", "a2", "b2", "a3", "b3", "a4",
        // "b4", "a5", "b5" };

        String[] str1 = new String[5];
        System.arraycopy(inputString, 0, str1, 0, 5);
        System.out.println("String Array str1");
        for (int i = 0; i < str1.length; i++) {
            System.out.print(str1[i]);
        }
        System.out.println();
        String[] str2 = new String[5];
        System.arraycopy(inputString, 5, str2, 0, 5);
        // System.out.println(str2.length);
        System.out.println("String Array str2");

        for (int i = 0; i < str2.length; i++) {
            System.out.print(str2[i]);
        }

        String temp = "";
        int i = 0, j = 0;

        for (i = 0; i < str1.length; i++) {
            temp = temp + str1[i];
            for (j = i; j < str2.length; j++) {
                if (j > i) {
                    break;
                }
                temp = temp + str2[j];
            }
        }
        System.out.println("\nFinal String " + temp);

        System.out.println();

    } // end main()
} // end class ArrayApp

问题是 - 使用套装可以改善吗？我尝试迭代集合，但这对我不起作用。我需要在这里使用其他任何集合类吗？

感谢您的时间。

BTW这里是O / P

String Array str1 a1a2a3a4a5 String Array str2 b1b2b3b4b5 Final 字符串a1b1a2b2a3b3a4b4a5b5

Answer 1

一个显而易见的方法是简单地对数组进行排序（可能是由于它的长度而导致插入排序 - 或者仅Arrays.sort()重新使用API代码）。

或者，你可以使用一个带有两个索引i和j的循环，分别从0和5开始，然后只放i在新数组中的第th个元素，然后是j，依此类推，每次递增每个索引，直到您填充整个结果数组。后者可能在计算上更有效率（因为在最坏的情况下它是O（n）），但它可能不太明显它应该做什么。

或者，您甚至可以完全展开循环，只需执行以下操作：

String[] newArray = new String[]
{
    inputString[0], inputString[5],
    inputString[1], inputString[6],
    inputString[2], inputString[7],
    inputString[3], inputString[8],
    inputString[4], inputString[9]
}

这实际上是计算效率最高的方式 - 尽管是最不通用的。

Answer 2

听起来就像你想要的那样：

String[] outputString = new String[inputString.length];
for (int i = 0; i < inputString.length / 2; i++) {
    outputString[i * 2] = inputString[i];
    outputString[i * 2 + 1] = inputString[i + inputString.length / 2];
}

但不清楚它是否真正只是你想要的交错......

（对于微优化，你可以尝试每次迭代只计算i * 2一次，并将inputString.length / 2从循环中取出。我怀疑JIT编译器会为你完成所有这些... ）

无论如何，这已经从O（n ²）减少到O（n）。我们还不清楚为什么你当前的代码开始使用String而不是String[]。（问题也不清楚，因为你谈论一个字符串，但随后提供一个字符串数组......）

完整代码：

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        String[] inputString = { "a1", "a2", "a3", "a4", "a5", 
            "b1", "b2", "b3", "b4", "b5"};
        String[] outputString = new String[inputString.length];
        for (int i = 0; i < inputString.length / 2; i++) {
            outputString[i * 2] = inputString[i];
            outputString[i * 2 + 1] = inputString[i + inputString.length / 2];
        }

        System.out.println(Arrays.toString(inputString));
        System.out.println(Arrays.toString(outputString));
    }
}

输出：

[a1, a2, a3, a4, a5, b1, b2, b3, b4, b5]
[a1, b1, a2, b2, a3, b3, a4, b4, a5, b5]

这看起来与您的规格完全相同......

Answer 3

您必须告诉我们转换背后的理由：

它只是通过拾取每个第5个元素直到结束重新排列数组，然后在下一个元素重新开始，重复5次？即重新排列为arr[0], arr[5], arr[10]..., arr[1], arr[6], arr[11], .... arr[2], arr[7], arr[12]...

或者通过排序第二个字符然后第一个来重新排列？

例如，如果给你一个数组 ["z9", "y2", "a2", "b1", "c4", "t7", "s6"]

最终结果应该是什么？

["z9", "t7", "y2", "s6", "a2", "b1", "c4"]

或

[ "b1", "a2", "y2", "c4", "s6", "t7", "z9"]？

这可能导致一种非常不同的“优化”方式

第一个可以简单地完成

for (int i = 0; i < 5; ++i) {
  for (int j = i; j < arr.length; j+=5) {
    resultArrayList.add(arr[j]);
  }
}

第二个就是

Arrays.sort(arr, new Comparator<String> {
  int compare(String s1, String s2) {
    return ("" + s1.charAt(1) + s1.charAt(0)).compareTo("" + s1.charAt(1) + s1.charAt(0));
  }
}

对于后一种情况，您可以通过提供更有效的比较功能进一步优化。

Answer 4

也许如下所示，它会为您提供所需的输出。

public class Test {
    public static void main(String[] args) {

        String[] inputString = { "a1", "a2", "a3", "a4", "a5", "b1", "b2",
                "b3", "b4", "b5" };

        Arrays.sort(inputString, new Comparator<String>() {

            private String reverse(String s) {
                return new StringBuilder(s).reverse().toString();
            }

            @Override
            public int compare(String arg0, String arg1) {
                return reverse(arg0).compareTo(reverse(arg1));
            }
        });

        System.out.println(Arrays.toString(inputString));
    }

}

如何通过优化这段Java代码来改进

4 个答案: