Fatal编程技术网
  • java/
  • Java 对零、负数和正数数组进行排序

Java 对零、负数和正数数组进行排序

java arrays sorting

Java 对零、负数和正数数组进行排序,java,arrays,sorting,Java,Arrays,Sorting,我有一个Java数组 int num[] = {5, -3, 0, -18, 1, 2, 0}; 我想让它看起来像这样 {-3, -18, 0, 0, 5, 1, 2} 我现在拥有的是这个 for (int i=0; i<num.length;i++) { for (int j=1; j<num.length-1;j++) { if (num[j]<0) {

我有一个Java数组

int num[] = {5, -3, 0, -18, 1, 2, 0};
我想让它看起来像这样

{-3, -18, 0, 0, 5, 1, 2}
我现在拥有的是这个

for (int i=0; i<num.length;i++)
    {
        for (int j=1; j<num.length-1;j++)
        {
            if (num[j]<0)
            {
                temp=num[j];
                c=num[j-1];
                num[j-1]=temp;
                num[j]=c;
            } 
        }  
    }
但这种排序只是负数，我找不到如何对零进行排序的解决方案。
你能帮帮我吗？

主要思想是让两个指针从int[]的开头和结尾向内迭代，直到它们相遇，如果正负指针放错了位置，就在途中交换它们。这将有助于：

public class Solution {
    public void sortNumbers(int[] A) {
        int a = 0;
        int b = A.length - 1;
        for (int i = 0; i < A.length && i <= b; i++) {
            int cur = A[i];
            if (cur < 0) {
                this.swap(A, i, a);
                a++;
            } else if (cur > 0) {
                this.swap(A, i, b);
                b--;
                i--;
            }
        }
    }

    private void swap(int[] A, int i, int j) {
        int tmp = A[i];
        A[i] = A[j];
        A[j] = tmp;
    }
}
运行时是打开的，其中n是int[]的长度。

主要思想是让两个指针从int[]的开头和结尾向内迭代，直到它们相遇，如果正负指针放错了位置，则在途中交换它们。这将有助于：

public class Solution {
    public void sortNumbers(int[] A) {
        int a = 0;
        int b = A.length - 1;
        for (int i = 0; i < A.length && i <= b; i++) {
            int cur = A[i];
            if (cur < 0) {
                this.swap(A, i, a);
                a++;
            } else if (cur > 0) {
                this.swap(A, i, b);
                b--;
                i--;
            }
        }
    }

    private void swap(int[] A, int i, int j) {
        int tmp = A[i];
        A[i] = A[j];
        A[j] = tmp;
    }
}
运行时处于打开状态，其中n是int[]的长度。

您可以使用简单的冒泡排序，比较相邻元素的符号，并交换那些站错i的元素。Ei-th的符号大于i+1-th：

冒泡排序是稳定的，所以这里的等号元素，等号元素被认为是那些具有相同符号的元素，不会改变它们的顺序，给你想要的结果。由于不是很有效，这个简单的算法仍然有助于理解排序方法是如何实现的，它不需要额外的空间，只对初始数组进行操作。

您可以使用一个简单的冒泡排序，比较相邻元素的符号，并交换站错的元素。Ei-th的符号大于i+1-th：

冒泡排序是稳定的，所以这里的等号元素，等号元素被认为是那些具有相同符号的元素，不会改变它们的顺序，给你想要的结果。由于不是很有效，这个简单的算法仍然有助于理解排序方法是如何实现的，它不需要额外的空间，只对初始数组进行操作。

下面是一个简单的实现，使用带do…while循环和for内部循环的布尔值：

public static void main(String[] args) {
    int num[] = {5, -3, 0, -18, 1, 2, 0};

    int temp = 0;
    boolean finished = false;

    do{
        finished = true; // This will stay true if nothing needs to be changed in your array.
        for (int i = 0 ; i < num.length - 1 ; i++){
            if (num[i] > num[i+1]){
                finished = false; // Can not go off the loop if it is not sorted yet.
                temp = num[i]; // Interchanging of array's indexes
                num[i] = num[i+1];
                num[i+1] = temp;
            }
        }
    } while(!finished);

    System.out.println(Arrays.toString(num));
}
下面是一个简单的实现，使用带有do…while循环和for内部循环的布尔值：

public static void main(String[] args) {
    int num[] = {5, -3, 0, -18, 1, 2, 0};

    int temp = 0;
    boolean finished = false;

    do{
        finished = true; // This will stay true if nothing needs to be changed in your array.
        for (int i = 0 ; i < num.length - 1 ; i++){
            if (num[i] > num[i+1]){
                finished = false; // Can not go off the loop if it is not sorted yet.
                temp = num[i]; // Interchanging of array's indexes
                num[i] = num[i+1];
                num[i+1] = temp;
            }
        }
    } while(!finished);

    System.out.println(Arrays.toString(num));
}
您可以将Arrays.sort与自定义比较器一起使用，该比较器将保留等号数字的顺序：

Integer[] num = {5, -3, 0, -18, 1, 2, 0};
Arrays.sort(num, (a, b) -> Integer.signum(a) - Integer.signum(b));
System.out.println(Arrays.toString(num)); // [-3, -18, 0, 0, 5, 1, 2]
编辑：既然OP只是想要一个普通的排序，那就太好了

Arrays.sort(num);
您可以将Arrays.sort与自定义比较器一起使用，该比较器将保留等号数字的顺序：

Integer[] num = {5, -3, 0, -18, 1, 2, 0};
Arrays.sort(num, (a, b) -> Integer.signum(a) - Integer.signum(b));
System.out.println(Arrays.toString(num)); // [-3, -18, 0, 0, 5, 1, 2]
编辑：既然OP只是想要一个普通的排序，那就太好了

Arrays.sort(num);
有许多不同的排序可用于对整数数组进行排序，从简单的冒泡排序到稍微复杂的堆排序。有些排序比其他排序快，例如堆排序比冒泡排序快，但这主要影响大型数组。这是由于互换的数量和数字之间的比较

气泡排序

堆排序

有许多不同的排序可用于对整数数组进行排序，从简单的冒泡排序到稍微复杂的堆排序。有些排序比其他排序快，例如堆排序比冒泡排序快，但这主要影响大型数组。这是由于互换的数量和数字之间的比较

气泡排序

堆排序

如果您有二维数组，可以根据每个数组的第一个元素或第二个元素对其进行排序，如下所示：

例如，我们想要排序 arr=[-2147483646，-2147483645]，[21474836462147483647]]基于每个数组的第二个元素。我们在最新的Java8中这样做

Arrays.sortarr、Comparator.comparingInta->a[1]

这将处理正整数和负整数。

如果您有二维数组，可以根据每个数组的第一个元素或第二个元素对其进行排序，如下所示：

例如，我们想要排序 arr=[-2147483646，-2147483645]，[21474836462147483647]]基于每个数组的第二个元素。我们在最新的Java8中这样做

Arrays.sortarr、Comparator.comparingInta->a[1]

这将考虑正整数和负整数。

时间复杂度：On，空间复杂度：O1

public void sortNumbers(int[] nums) {
    int start = 0;
    int end = nums.length - 1;
    int index = 0;

    while (start < end && index <= end) {
        if (nums[index] < 0) {
            int temp = nums[index];
            nums[index] = nums[start];
            nums[start] = temp;
            start++;
            index++;

        } else if (nums[index] > 0) {
            int temp = nums[index];
            nums[index] = nums[end];
            nums[end] = temp;
            end--;
        } else {
            index++;
        }
    }
    System.out.println(Arrays.toString(nums));

}
时间复杂度：On，空间复杂度：O1

public void sortNumbers(int[] nums) {
    int start = 0;
    int end = nums.length - 1;
    int index = 0;

    while (start < end && index <= end) {
        if (nums[index] < 0) {
            int temp = nums[index];
            nums[index] = nums[start];
            nums[start] = temp;
            start++;
            index++;

        } else if (nums[index] > 0) {
            int temp = nums[index];
            nums[index] = nums[end];
            nums[end] = temp;
            end--;
        } else {
            index++;
        }
    }
    System.out.println(Arrays.toString(nums));

}
我不懂排序逻辑，你能展开一点吗？我需要在数组求值时有负数，后面是零，最后是正数。@Tunaki将一个未排序的数组变成另一个未排序的数组…？好的，但是，是否应该有关于正数的排序规则呢？之所以只对负数进行排序，是因为在循环中，你只是比较0。我不理解排序逻辑，你能扩展一下吗？我需要在数组中求负数，然后是零，最后是正数。@Tunaki将一个未排序的数组转换为另一个未排序的数组…？好的，但是是否应该有任何关于正数的排序规则？它只对负数排序的原因是因为在循环中，您只将其与0进行比较。这与使用算法有什么不同？@dguay我的朋友。排序一点也不好玩。@dguay array.Sort
它的实现非常简单differently@SashaSalauyou也许，但是Arrays.sort输出是一样的。如果他只是想对数组进行排序，为什么需要实现新的排序算法？就像“肉桂回答”…这和使用算法有什么不同？@dguay我的朋友。排序一点也不好玩。@dguay Arrays.Sort的实现非常简单differently@SashaSalauyou也许，但是Arrays.sort输出是一样的。如果他只是想对数组进行排序，为什么需要实现新的排序算法？就像@肉桂回答…Integer.signum可能是一个更好的选择。加上一个lambda是我视图中最干净的方法Integer.signum可能是一个更好的选择。加上一个lambda是我视图中最干净的方法首先我误解了你的问题，我只是根据实际需要编辑了我的答案。首先我误解了你的问题，我刚刚编辑了我的答案，以符合实际要求我认为循环终止条件I