正负交替 java

旧城等待， 2022-11-15 11:48 114阅读 0赞

题目

给一个包含正负整数的数组，要求对这个数组中的数进行重新排列，使得其正负交替出现。首先出现负数，然后是正数，然后是负数。有多余的数的一方，就放在末尾。

如输入  
\[1, 2, 3, -4\]  
输出  
\[-4, 1, 2, 3\]，  
输入  
\[1,-3,2,-4,-5\]  
输出  
\[-3,1,-4,2,-5\]

要求使用O(1)的额外空间。

问1 ：如果不需要保持正数序列和负数序列各自原来的顺序，如何做？时间复杂度是多少？

问2：如果需要保持正数序列和负数序列各自原来的顺序，如何做？时间复杂度是多少？

解答

对于不需要保持正数序列和负数序列各自原来的顺序的情况。可以采用两根指针的方式，第一根指针指向第一个不满足正负交替的位置，第二根指针指向第一根指针之后和第一根指针所指向的数符号相反的数。交换这两个数，然后继续上述操作。举个例子：

\[1, -1, -2, -3, -4, -5, 2, 3, 4, 5\]

此时第一个不满足正负交替的位置的数是-2，个数之后第一个找到的符号相反的数是2，交换这两个数，得到：

\[1, -1, 2, -3, -4, -5, -2, 3, 4, 5\]

容易得出的是，2与-2之间，一定全都是负数，交换之后也仍是，那么，交换之后，第一根指针可以向后挪动两个位置，继续寻找不满足正负交替的数；第二根指针可以向后挪动一个位置（或从第一根指针的下一个位置开始），继续寻找第一个与第一根指针所在位置的数符号相反的数。时间复杂度O(n)，空间复杂度O(1)

对于需要正负数各自保持原来的顺序的情况，方法与上述方法雷同。区别在于，当两根指针找到可以交换位置的两个数以后，并不是采用交换的方法，而是采用让两根指针所指向的区间循环右移一位的方法。如： \[1, -1, -2, -3, -4, -5, 2, 3, 4, 5\] 所示，将下划线区间循环右移，得到了\[1, -1, 2, -2, -3, -4, -5, 3, 4, 5\]，这样才能在不影响顺序的情况下，使得正整数2换到-2的所在位置。时间复杂度O(n^2)，空间复杂度O(1)

package com.company;
    
    
    
    public class Main { 
    
        public static void main(String[] args) { 
    	// write your code here
    
            int[] arr = { 1,2,-1,-2,3,5,4-5,-6,-6,-7};
           // sortA(arr);
            sortB(arr);
    
        }
    
    //保持正数序列和负数序列各自原来的顺序,时间复杂度O(n^2)
        static void sortA(int[] arr)
        { 
            int n =  arr.length;
            for (int i = 0; i < n; i++)
            { 
                if (i % 2 == 0 && arr[i] < 0)
                    continue;
                if (i % 2 == 1 && arr[i]>0)
                    continue;
                if (i % 2 == 0 && arr[i]>0)
                { 
                    int j;
                    int temp;
                    for (j = i + 1; j < n ; j++) { 
                        if(arr[j]<0) { 
                            temp = arr[j];
                            for (; j > i; j--)
                            { 
                                arr[j] = arr[j - 1];
                            }
                            arr[i] = temp;
                            break;
                        }
    
                    }
    
                }
                if (i % 2 == 1 && arr[i]<0)
                { 
                    int j;
                    int temp;
                    for (j = i + 1; j < n ; j++){ 
                        if(arr[j]>0) { 
                            temp = arr[j];
                            for (; j > i; j--)
                            { 
                                arr[j] = arr[j - 1];
                            }
                            arr[i] = temp;
                            break;
                        }
                    }
                }
            }
        }
    //不需要保持正数序列和负数序列各自原来的顺序,时间复杂度O(n)
       static void sortB(int[] arr)
        { 
            int n = arr.length;
            for (int i = 0; i < n; i++)
            { 
                if (i % 2 == 0 && arr[i] < 0)
                    continue;
                if (i % 2 == 1 && arr[i]>0)
                    continue;
                if (i % 2 == 0 && arr[i]>0)
                { 
                    int j;
                    int temp;
                    for (j = i + 1; j < n; j++){ 
                        if(arr[j]<0) { 
                            temp = arr[j];
                            arr[j] = arr[i];
                            arr[i] = temp;
                            break;
                        }
                    }
                }
                if (i % 2 == 1 && arr[i]<0)
                { 
                    int j;
                    int temp;
                    for (j = i + 1; j < n; j++){ 
                        if(arr[j]>0) { 
                            temp = arr[j];
                            arr[j] = arr[i];
                            arr[i] = temp;
                            break;
                        }
                    }
                }
            }
        }
    }