Java 一个非常长（未知大小）的正整数整数数组，由负数分隔。如何在线性时间内反转这些正子阵列？

假设我们有一个正整数和负整数的整数数组流，我想用负数作为分隔符，并反转正子数组。例如[1,2,3,4，-5,6,7,8，-9，…]变成[4,3,2,1，-5,8,7,6，-9，…]

---

我试图提出一个线性的（可能是就地的）解决方案，但我做不到

我没有尝试此代码，但它应该可以工作：

public int[] convert(int[] c){
   int[] ret = new int[c.length];
   ArrayList<Integer> rev = new ArrayList<>();
   for(int i = 0; i<c.length; i++){
      if(c[i]>=0){
         //If the number is positive, schedule it to be reversed
         ret.add(i);
      }else{
         //If the number is negative, add the array reversed
         //and then the number itself
         int s = rev.size();
         for(int y = 0; y<s; y++){
            ret[i-1-y] = rev.get(y);
         }
         //Recreate the list to clear the scheduled content
         rev = new ArrayList<>();
         ret[i] = c[i];
      }
   }
   //Flush the end of the array
   int s = rev.size();
   for(int y = 0; y<s; y++){
      ret[c.length-1-y] = rev.get(y);
   }
}

public int[]convert（int[]c）{
int[]ret=新的int[c.长度]；
ArrayList rev=新的ArrayList（）；
对于（int i=0；i=0）{
//如果数字为正数，则计划将其反转
补编（i）；
}否则{
//如果数字为负数，则添加反向数组
//然后是数字本身
int s=版本大小（）；
for（int y=0；y在测试否定if数时循环到数组中。
为整数创建数组0f，并对创建的数组使用Collections.reverse（）

ArrayList<ArrayList<Integer>> lists = ArrayList<ArrayList<Integer>>();
int subCounter=0;
lists.add(new ArrayList<Integer>());

for(int i=0; i originalArray.length; i++){

   (if originalArry[i] < 0){

      lists.add(new ArrayList<Integer>());
      subCounter++;

   }
   else{
        lists.get(subCounter).add(originalArry[i]);
   }
}

int[] newArray = new int[oroginalArray.length];

int counter = 0;
for(ArrayList<Integer> list : lists){

    Collections.reverse(list);
   for(int i=0; i < list.size(); i++){

       newArray[counter] = list.get(i);
       counter++;

   }

   newArray[counter] = originalArray[counter]; // add the separator
   counter++;


}

ArrayList list=ArrayList（）；
整数次计数=0；
添加（新的ArrayList（））；
for（int i=0；i originalArray.length；i++）{
（如果原始[i]<0）{
添加（新的ArrayList（））；
子计数器++；
}
否则{
list.get（subCounter）.add（originalArry[i]）；
}
}
int[]newArray=newint[oroginalArray.length]；
int计数器=0；
对于（ArrayList:列表）{
收款。反向（列表）；
对于（int i=0；i

它可能需要调试，但原理就在那里。
这是可行的。我刚刚测试过它。（简短而甜蜜）

int[]数组=新的int[]{1,2,3,4，-5,6,7,8，-9,10，-11,12,13,14,15}；
ArrayList正片=新的ArrayList（）；
ArrayList preFinalArray=新的ArrayList（）；
for（int i:array）{
如果（i>0）为正，则添加（新整数（i））；
否则{
对于（int j=posities.size（）-1；j>=0；j--）preFinalArray.add（posities.get（j））；
preFinalArray.add（新整数（i））；
肯定。清除（）；
}
}
if（posities.size（）>0）for（int i=posities.size（）-1；i>=0；i--）preFinalArray.add（新整数（posities.get（i））；
int[]newArray=newint[preFinalArray.size（）]；
对于（inti=0；i
到目前为止你都尝试了什么？如果我们使用额外的存储空间，也许我们可以把每个正片都放在一个堆栈上，一看到负片，我们就弹出堆栈（将内容反转），对吗？这是个主意。应该也行。实际上这是个更好的主意。
  int[] array = new int[]{1,2,3,4,-5,6,7,8,-9,10,-11,12,13,14,15};
  ArrayList<Integer> positives = new ArrayList<Integer>();
  ArrayList<Integer> preFinalArray = new ArrayList<Integer>();
  for(int i: array){
    if(i>0) positives.add(new Integer(i));
    else{
        for(int j = positives.size()-1; j>=0; j--) preFinalArray.add(positives.get(j));
        preFinalArray.add(new Integer(i));
        positives.clear();
    }
  }
  if(positives.size()>0) for(int i = positives.size()-1; i>=0; i--) preFinalArray.add(new Integer(positives.get(i)));
  int[] newArray = new int[preFinalArray.size()];
  for(int i = 0; i < newArray.length; i++) newArray[i]=preFinalArray.get(i).intValue();
  for(int i: newArray)System.out.println(i);