Question

我有一个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;
            } 
        }  
    }

但这只是负数，我找不到解决方案如何排序零。你能帮帮我吗？

Answer 1

您可以将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);

Answer 2

主要思想是从int[]的头部和尾部向内迭代2个指针直到它们相遇，如果positive和negative放错位置，则在路上交换它们。这将有效：

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;
    }
}

运行时为O（n），其中n是int[]

的长度

Answer 3

时间复杂度：O(n) 空间复杂度：O(1)

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));

}

Answer 4

您可以使用简单的冒泡排序，比较相邻元素的符号并交换错误的人（即i-th有更大的符号＆＃34;而不是(i+1)-th）：

for (int j = num.length - 1; j >= 0; j--) {
    for (int i = 0; i < j; i++) {
        if (Integer.signum(num[i]) > Integer.signum(num[i+1])) {  // comparing signs
            int temp = num[i];
            num[i] = num[i+1];
            num[i+1] = temp;               
        } 
    }  
}

冒泡排序稳定，所以＆＃34;相等＆＃34;元素（这里，相同的元素被认为具有相同符号的元素）永远不会改变它们的顺序，给你想要的结果。这个简单的算法不是很有效，它仍然有助于理解如何实现排序方法，它不需要额外的空间并且只能在初始数组上运行。

Answer 5

这是一个简单的实现，使用带有do ... while循环的boolean和用于内部循环：

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));
}

<强>输出

[-18, -3, 0, 0, 1, 2, 5]

Answer 6

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

冒泡排序

public class BubbleSort 
{
    public void sortArray(int[] a)
    {       
        int c, d, swap;

        for(c = 1; c < a.length; c++)
        {
            for (d = 0; d < a.length - c; d++) 
            {
                if (a[d] > a[d+1])
                {
                    swap = a[d];
                    a[d] = a[d+1];
                    a[d+1] = swap;
                }
            }
        }

        for(int i=0;i<a.length;i++)
        {
            int correctNumber = i+1;
            System.out.println("Value "+correctNumber+" of the sorted array which was sorted via the Bubble Sort is: "+a[i]);
        }
    }
}

堆排序

public class HeapSort 
{
    private static int[] a;
    private static int n;
    private static int left;
    private static int right;
    private static int largest;


    public static void buildheap(int []a)
    {
        n=a.length-1;
        for(int i=n/2;i>=0;i--)
        {
            maxheap(a,i);
        }
    }

    public static void maxheap(int[] a, int i)
    { 
        left=2*i;
        right=2*i+1;
        if(left <= n && a[left] > a[i])
        {
            largest=left;
        }
        else
        {
            largest=i;
        }

        if(right <= n && a[right] > a[largest])
        {
            largest=right;
        }

        if(largest!=i)
        {
            exchange(i,largest);
            maxheap(a, largest);
        }
    }

    public static void exchange(int i, int j)
    {
        int t=a[i];
        a[i]=a[j];
        a[j]=t; 
    }

    public static void sort(int[] a0)
    {
        a=a0;
        buildheap(a);

        for(int i=n;i>0;i--)
        {
            exchange(0, i);
            n=n-1;
            maxheap(a, 0);
        }

        for(int i=0;i<a.length;i++)
        {
            int correctNumber = i+1;
            System.out.println("Value "+correctNumber+" of the sorted array which was sorted via the Heap Sort is: "+a[i]);
        }
    }
}

Answer 7

如果您有2D数组，则可以按照每个数组的第一个元素或第二个元素对其进行排序，如下所示：

例如，我们要排序
arr= [[-2147483646,-2147483645],[2147483646,2147483647]]基于每个数组的第二个元素。我们就像在最新的Java 8中那样做

Arrays.sort(arr, Comparator.comparingInt(a -> a[1]));

这处理正整数和负整数。

对零，负数和正数的数组进行排序

7 个答案: