Question

我无法解决问题，我需要数组A的输出，例如{1,2,3,4，-1，-2，-3，-4} 从数组中的随机数开始，然后将其写入另一个数组B。到目前为止，我的实验代码无法正常工作

public static void main(String[] args) {

    int a[] = {5,4,3,2,1,-3,-2,-30};
    int length = a.length - 1;

    for (int i = 0 ; i < length ; i++) {
        for (int j = 0 ; j < length-i ; j++) {
            if (a[j] < a[j+1]) {
                int swap = a[j];
                a[j] = a[j+1];
                a[j+1] = swap;
            }
        }
    }

    for (int x : a) {
        System.out.print(x+" ");
    }
}

输出为5 4 3 2 1 -2 -3 -30，但我需要1,2,3,4,5，-2，-3，-30

更新：

public static void main(String[] args) {

    int a[] = {5,4,3,2,1,-3,-2,-30,-1,-15,8};
    int length = a.length - 1;

    for (int i = 0 ; i < length ; i++) {
        for (int j = 0 ; j < length-i ; j++) {
            if (a[j] < a[j+1]) {
                int swap = a[j];
                a[j] = a[j+1];
                a[j+1] = swap;
            } else {
                if (a[j] > a[j+1] && a[j+1] > 0) {
                    int swap = a[j];
                    a[j] = a[j+1];
                    a[j+1] = swap;
                }
            }
        }
    }

    for (int x : a) {
        System.out.print(x+" ");
    }
}

我离目标越来越近，但8 1 2 3 4 5 -1 -2 -3 -15 -30，那个数字8毁了一切

Answer 1

如果我对您的理解正确，那么您想对两件事进行排序。正数从低到高，负数从高到低。

您可以先从高到低排序，然后在数组中第二次跳过所有正值，然后从高到低排序。

这有帮助吗？我可以编写一些代码，但是我认为这是您现在想学习的内容：）

Answer 2

添加if-else来区分肯定情况和否定情况。

if (a[j] < 0) {
    if (a[j] < a[j+1]) {
        int swap = a[j];
        a[j] = a[j+1];
        a[j+1] = swap;
    }
} else {
    if (a[j] > a[j+1] && a[j+1] > 0) {
        int swap = a[j];
        a[j] = a[j+1];
        a[j+1] = swap;
    }
}

Answer 3

算法：

遍历数组，将正数存储在一个数组中，将负数存储在另一个数组中。 O（i）
按正序排列正数组。 O（mLog（m））
按负数降序排列。 O（nLog（n））
创建一个具有输入大小的最终数组。
添加所有正数组排序值。然后添加负数组排序值。 O（i）

总计：如果m> n，则O（i）+ O（mLog（m））+ O（nLog（n））+ O（i）= O（mLog（m））

Answer 4

我在这里使用了库函数。但是，如果您愿意，可以使用相同的思路编写函数。

public class PostivieAsendingNegativeDesending implements Comparator<Integer> {

        public static void main(String args[]) {

            int fullList[] = {5, 4, 3, 2, 1, -3, -2, -30};
            ArrayList<Integer> subList = new ArrayList<>();
            ArrayList<Integer> subList2 = new ArrayList<>();
            for (int i = 0; i < fullList.length; i++) {
                if (fullList[i] < 0) {
                    subList2.add((fullList[i]));
                } else {
                    subList.add(fullList[i]);
                }
            }
            Collections.sort(subList);
            Collections.sort(subList2, new PostivieAsendingNegativeDesending());
            subList.addAll(subList2);
            for (int i = 0; i < subList.size(); i++) {
                System.out.print(subList.get(i)  + " ");
            }
            System.out.println("");
        }

        @Override
        public int compare(Integer n1, Integer n2) {
            return n2 - n1;
        }
    }

Answer 5

这将完成仅使用基本循环的技巧

public static void main(String[] args) {
    int a[] = { 5, 4, 3, 2, 1, -3, -2, -30 };
    int length = a.length - 1;

    int pos = 0, neg = 0;
    // find total count of positive and negative numbers
    for (int i = 0; i <= length; i++) {
        if (a[i] < 0)
            neg++;
        else
            pos++;
    }

    // initialize the arrays based on 'pos' and 'neg'
    int posArr[] = new int[pos];
    int negArr[] = new int[neg];

    // store pos and neg values in the arrays
    int countPos = 0, countNeg = 0;
    for (int i = 0; i <= length; i++) {
        if (a[i] < 0) {
            negArr[countNeg] = a[i];
            countNeg++;
        } else {
            posArr[countPos] = a[i];
            countPos++;
        }
    }

    // sort positive numbers
    for (int i = 0; i < posArr.length - 1; i++) {
        for (int j = 0; j < posArr.length - 1 - i; j++) {
            if (posArr[j] > posArr[j + 1]) {
                int swap = posArr[j];
                posArr[j] = posArr[j + 1];
                posArr[j + 1] = swap;
            }
        }
    }

    // sort negative numbers
    for (int i = 0; i < negArr.length - 1; i++) {
        for (int j = 0; j < negArr.length - 1 - i; j++) {
            if (negArr[j] < negArr[j + 1]) {
                int swap = negArr[j];
                negArr[j] = negArr[j + 1];
                negArr[j + 1] = swap;
            }
        }
    }

    // 1. print out posArr[] and then negArr[]
    // or 
    // 2. merge them into another array and print

}

逻辑解释如下：

查找正数和负数的总数。
在各个数组中创建和存储正值和负值。
按升序排列正数组。
按负序排列负数组。
先打印正数组，然后再打印负数组，或者将它们合并为另一个并打印。

Answer 6

我建议另一种方法。您应该尝试制定精确比较必须遵循的规则。

您的要求似乎具有以下规则：

正数始终位于负数之前。
正数按升序排列。
负数按降序排列。是的，我说下降。由于较高的数字位于较低的数字之前，因此-2大于-7。

警告：您正在使用嵌套的for循环，这意味着如果数组变大，处理时间将成倍增长。好消息是：您不需要嵌套for循环进入另一个for循环。我建议改写Comparator：

// The contract of Comparator's only method 'compare(i, j)' is that you
// return a negative value if i < j, a positive (nonzero) value if i > j and
// 0 if they are equal.
final Comparator<Integer> c = (i, j) -> { // I'm using a lambda expression,
                                          // see footnote

    // If i is positive and j is negative, then i must come first
    if (i >= 0 && j < 0) {
        return -1;
    }
    // If i is negative and j is positive, then j must come first
    else if (i < 0 && j >= 0) {
        return 1;
    }
    // Else, we can just subtract i from j or j from i, depending of whether
    // i is negative or positive
    else {
        return (i < 0 ? j - i : i - j);
    }
}

您的代码可能如下所示：

int[] a = { 5, 4, 3, 2, 1, -3, -2, -30 };

int[] yourSortedIntArray = Arrays.stream(a)
    .boxed()
    .sorted(c) // Your Comparator, could also added inline, like
               // .sorted((i, j) -> { ... })
    .mapToInt(i -> i)
    .toArray();

^{Lambda表达式是Java 8中的一个新概念。Java教程提供了一些valuable information。}

Java排序数组从正升到负升

6 个答案: