Question

我正在尝试编写一个mehtod，它采用一组int，然后重新排列数组中的数字，以便负数首先出现。该阵列不需要以任何方式进行排序。唯一的要求是解决方案必须是线性的，并且不使用额外的数组。

例：输入： {1，-5,6，-4,8,9,4，-2} 输出： {-5，-2，-4,8,9,1,4,6}

现在作为Java中的菜鸟和编程通常我不能100％确定什么是线性解决方案，但我的猜测是它必须是一个不在循环中使用循环的解决方案。

我目前有一个糟糕的解决方案，我知道它不起作用（我也理解为什么），但我似乎无法想到任何其他解决方案。如果我被允许在循环或其他数组中使用循环但是我不被允许这个任务很容易。

我的代码：

public static void separateArray(int[] numbers) {
    int i = 0;
    int j = numbers.length-1;
    while(i<j){

        if(numbers[i] > 0){
            int temp;
            temp = numbers[j];
            numbers[j] = numbers[i];
            numbers[i] = temp;
            System.out.println(Arrays.toString(numbers));
        }

        i++;
        j--;
    }
}

非常感谢任何帮助（如果您还可以定义一个＆＃34;线性解决方案＆＃34;是非常好的。我在互联网上搜索并发现了非常模糊的解释但没有明确的定义）。谢谢！

编辑：解决！

最终守则：

public static void separateArray(int[] numbers) {
    int i = 0;
    int j = numbers.length-1;
    while(i<j){

        if(numbers[i] >= 0 && numbers[j] < 0){
            int temp;
            temp = numbers[j];
            numbers[j] = numbers[i];
            numbers[i] = temp;
        }

        if(numbers[i] < 0){
            i++;
        }

        if(numbers[j] >= 0){
            j--;
        }
    }
}

Answer 1

您只需更改一行即可使其（大部分）正常工作。但是您需要更改两行以正确处理输入中的零。我已通过下面的“FIXME”评论强调了这些最低限度的必要变更：

public static void separateArray(int[] numbers) {
    int i = 0;
    int j = numbers.length-1;
    while(i<j){
        if(numbers[i] > 0){ // FIXME: zero is not a "negative number"
            int temp;
            temp = numbers[j];
            numbers[j] = numbers[i];
            numbers[i] = temp;
        }
        i++; // FIXME: only advance left side if (numbers[i] < 0)
        j--;
    }
}

修改

对于那些不相信它会起作用的人，你可以在这里试试：https://ideone.com/dnAl5o

Answer 2

使用两个指针i和j的方法是一个良好的开端。

考虑一下你立即设置的循环不变量（空白）：

0（含）到i（不包括）范围内的元素均为否定;
范围j（不包括）至numbers.length（不包括）的元素均为非负数。

现在，您希望能够将i和j移到一起，直到它们相互通过，保留循环不变量：

如果i < numbers.length和numbers[i] < 0，您可以将i增加1;
如果j >= 0和numbers[j] >= 0，您可以将j减少1;
如果i < numbers.length和j >= 0，则numbers[i] >= 0和numbers[j] < 0。交换它们。

如果您在i == j + 1之前继续应用此策略，那么您最终会得到所需的情况：

numbers[a] < 0 for a in [0..i)
numbers[a] >= 0 for a in (j..numbers.length)，也写为numbers[a] >= 0 for a in (i-1..numbers.length)，也写为numbers[a] >= 0 for a in [i..numbers.length)。

因此，您已对数组进行了分区，以便所有负数都位于i - 元素的左侧，并且所有非负数都位于{{1}的右侧或右侧 - 元素。

希望这个算法应该易于遵循，从而实现。

Answer 3

线性解是一个带有run-time complexity Big-Oh（n）的解决方案，也被称为O（n），换句话说，你必须只遍历整个数组一次。要按线性时间排序，您可以尝试以下排序算法之一：

Answer 4

只有当所有负数位于右半侧而正数位于左半部分时，您的代码才有效。例如，您的代码将9与9交换，两者都是正数。因此，它取决于数组元素的顺序。正如斯科特说的那样，先试着用手做，然后你就会注意到你做错了。此外，打印您的阵列

Answer 5

//Move positive number left and negative number right side

public class ArrangeArray {
    public static void main(String[] args) {
        int[] arr = { -2, 1, -3, 4, -1, 2, 1, -5, 4 };
        for (int i = 0; i < arr.length; i++) {
            System.out.print(" " + arr[i]);
        }
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            // even
            if (arr[i] < 0) {
                for (int j = i + 1; j < arr.length; j++) {
                    if (arr[j] > 0) {
                        arr[j] = arr[i] + arr[j];
                        arr[i] = arr[j] - arr[i];
                        arr[j] = arr[j] - arr[i];
                        break;
                    }
                }
            }
        }
        System.out.println("");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(" " + arr[i]);
        }
    }
}

Answer 6

有一个简单的程序可以为您提供帮助。在此程序中，我使用了临时数组并执行了项目迭代次数。在那我开始从右边填充正值，从左边填充负数。

 public static void rearrangePositiveAndNegativeValues() {
        int[] a = {10,-2,-5,5,-8};
        int[] b = new int[a.length];
        int i = 0, j = a.length -1;

        for (int k = 0; k < a.length ; k++) {
            if (a[k] > 0) {
                b[j--] = a[k];
            } else {
                b[i++] = a[k];
            }
        }

        System.out.println("Rearranged Values : ");
        printArray(b);
    }

Answer 7

package ArrayProgramming;

import java.util.ArrayList;
import java.util.Arrays;

public class RearrangingpossitiveNegative {


    public static void main(String[] args) {
        int[] arr= {-1,3,4,5,-6,6,8,9,-4};
        ArrayList<Integer> al = new ArrayList<Integer>();
        for (int i=0;i<arr.length;i++) {
            if(arr[i]>0) {
                al.add(arr[i]);
            }
        }
        for (int i=arr.length-1;i>=0;i--) {
            if(arr[i]<0) {
                al.add(arr[i]);
            }
        }
        System.out.println(al);
    }
}

Answer 8

        private void btnUpdate_Click(object sender, EventArgs e)
        {

            XmlDocument doc = new XmlDocument();
            doc.PreserveWhitespace = true;
            doc.Load("Info.xml");

            XmlNamespaceManager ns = new XmlNamespaceManager(doc.NameTable);
            ns.AddNamespace("root", doc.DocumentElement.NamespaceURI);
            XmlNode Body = doc.SelectSingleNode("//root:Body", ns);
            ns.AddNamespace("child", Body.FirstChild.NextSibling.NamespaceURI);

            XmlNode nodeIr = doc.SelectSingleNode("//child:Name", ns);

            nodeIr.InnerText = txtBox1.Text;

            doc.Save("Info.xml");

        }

我们还可以通过创建两个新数组并根据给定条件向其中添加元素来做到这一点。后来加入他们两个以产生最终结果。

Java - 重新排列int数组，以便所有负数都在positivite数字之前

8 个答案: