解决编码问题'；偶数'；在Java中使用一个循环

这个问题是关于用Java编写代码来解决问题的

问题陈述：

public int[] evenOdd(int[] nums) {

boolean oddFound=false;
int count=-1;
int oddGap=0;

for(int i=0;i<nums.length;i++)
  {
     if(!(oddFound)&(nums[i]%2==0))
       continue;

       if((!oddFound)&(nums[i]%2==1))
       {
         oddFound=true;
         count=i;
         continue;
       }
       if((oddFound)&(nums[i]%2==1))
       {
         oddGap++;
         continue;
       }
        if((oddFound)&(nums[i]%2==0)) 
        {
         int temp=nums[count];
         nums[count]=nums[i];  
         nums[i]=temp;

         if(i>0)
             i--;

            if(oddGap>0)
            {
              oddGap--;
              count+=1;
              oddFound=true;
              continue;
             } 
             oddFound=false;
        } 

     }
     return nums;    

}

返回一个数组，该数组包含与给定数组完全相同的数字，但经过重新排列，使所有偶数位于所有奇数之前。除此之外，数字可以是任意顺序。您可以修改并返回给定数组，也可以创建新数组

偶奇数（{1,0,1,0,0,1,1}）→ {0,0,0,1,1,1,1}

偶奇数（{3，3，2}）→ {2,3,3}

偶奇数（{2，2，2}）→ {2，2，2}

这个问题很简单，有2个循环，我试图用1个循环来解决它。我相信它太长了，有没有其他有效的方法用1个循环来解决上面的问题？ 不要使用集合

我的解决方案：

public int[] evenOdd(int[] nums) {

boolean oddFound=false;
int count=-1;
int oddGap=0;

for(int i=0;i<nums.length;i++)
  {
     if(!(oddFound)&(nums[i]%2==0))
       continue;

       if((!oddFound)&(nums[i]%2==1))
       {
         oddFound=true;
         count=i;
         continue;
       }
       if((oddFound)&(nums[i]%2==1))
       {
         oddGap++;
         continue;
       }
        if((oddFound)&(nums[i]%2==0)) 
        {
         int temp=nums[count];
         nums[count]=nums[i];  
         nums[i]=temp;

         if(i>0)
             i--;

            if(oddGap>0)
            {
              oddGap--;
              count+=1;
              oddFound=true;
              continue;
             } 
             oddFound=false;
        } 

     }
     return nums;    

}

public int[]evenOdd（int[]nums）{
布尔值=false；
整数计数=-1；
int-oddGap=0；
对于（int i=0；i0）
我--；
如果（oddGap>0）
{
奥德盖普--；
计数+=1；
oddFound=true；
继续；
} 
oddFound=false；
} 
}
返回nums；
}

从0到N遍历偶数奇数。 对于遇到的每个偶数，将其复制到偶数奇数数组上所需的位置。 对于遇到的每个奇数num，将其存储在名为oddnum的单独数组中。 遍历整个数组后，只需将oddnum中的元素复制到evenOdd的后面

Ex:evenOdd={5,2,1,4} 第一步。将5复制到oddnum[0] 2.将2复制到偶数[0] 3.将1复制到oddnum[1] 4.将1复制到偶数[1]

---

5.cpy oddnum[0]到偶数奇[2]和oddnum[1]到偶数奇[3]

从0到N遍历偶数奇。 对于遇到的每个偶数，将其复制到偶数奇数数组上所需的位置。 对于遇到的每个奇数num，将其存储在名为oddnum的单独数组中。 遍历整个数组后，只需将oddnum中的元素复制到evenOdd的后面

Ex:evenOdd={5,2,1,4} 第一步。将5复制到oddnum[0] 2.将2复制到偶数[0] 3.将1复制到oddnum[1] 4.将1复制到偶数[1]

---

5.cpy oddnum[0]到evenOdd[2]和oddnum[1]到evenOdd[3]

您不需要任何临时列表或数组，因为您可以对元素进行原位重新排序

这是一个简单的算法：

定义两个指针，左指针和右指针（最初设置为数组的边界）

只要left不超过right，且

nums[left]

为偶数，则递增left

只要right不超过left并且

nums[right]

为奇数，则向右递减

如果left仍然小于right，则在left和right位置交换元素

只要左侧仍然小于右侧，重复2,3,4

明白了吗？下面是一些代码：

public int[] evenOdd(int[] nums) {
    // (1)
    int left = 0;
    int right = nums.length -1;
    do {
        // (2)
        while (left < right && nums[left] % 2 == 0)
            left += 1;
        // (3)
        while (right > left && nums[right] % 2 != 0)
            right -= 1;
        // (4)
        if (left < right) {
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;
        }
    } while (left < right);   // (5)
    return nums;
}

public int[]evenOdd（int[]nums）{
// (1)
int左=0；
int right=nums.length-1；
做{
// (2)
while（left左&&nums[右]%2！=0）
右-=1；
// (4)
if（左<右）{
int temp=nums[左]；
nums[左]=nums[右]；
nums[右]=温度；
}
}while（左<右）；/（5）
返回nums；
}

您不需要任何临时列表或数组，因为您可以就地对元素重新排序

这是一个简单的算法：

定义两个指针，左指针和右指针（最初设置为数组的边界）

只要left不超过right，且

nums[left]

为偶数，则递增left

只要right不超过left并且

nums[right]

为奇数，则向右递减

如果left仍然小于right，则在left和right位置交换元素

只要左侧仍然小于右侧，重复2,3,4

明白了吗？下面是一些代码：

public int[] evenOdd(int[] nums) {
    // (1)
    int left = 0;
    int right = nums.length -1;
    do {
        // (2)
        while (left < right && nums[left] % 2 == 0)
            left += 1;
        // (3)
        while (right > left && nums[right] % 2 != 0)
            right -= 1;
        // (4)
        if (left < right) {
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;
        }
    } while (left < right);   // (5)
    return nums;
}

public int[]evenOdd（int[]nums）{
// (1)
int左=0；
int right=nums.length-1；
做{
// (2)
while（left左&&nums[右]%2！=0）
右-=1；
// (4)
if（左<右）{
int temp=nums[左]；
nums[左]=nums[右]；
nums[右]=温度；
}
}while（左<右）；/（5）
返回nums；
}

由于允许创建新数组，且数字顺序无关，因此我将使用以下方法：

public int[] evenOdd(int[] nums) {
    int[] output = new int[nums.length];
    int evenPos = 0;
    int oddPos = nums.length-1;
    for (int i : nums) {
        if (i%2==0) {
            output[evenPos++]=i;
        } else {
            output[oddPos--]=i;
        }
    }

    return output;
}

更新：一个不太可读的版本，不需要额外的数组（按照@Seelenvirtuose的建议，只是没有额外的循环）

public int[]evenOdd（int[]nums）{
int-evenPos=0；
int oddPos=nums.length-1；
while（true）{
如果（evenPos>=oddPos | | evenPos>=nums.length | | oddPos，因为允许创建新数组，并且数字的顺序不相关，我将使用以下方法：

public int[] evenOdd(int[] nums) {
    int[] output = new int[nums.length];
    int evenPos = 0;
    int oddPos = nums.length-1;
    for (int i : nums) {
        if (i%2==0) {
            output[evenPos++]=i;
        } else {
            output[oddPos--]=i;
        }
    }

    return output;
}

更新：一个不太可读的版本，不需要额外的数组（按照@Seelenvirtuose的建议，只是没有额外的循环）

public int[]evenOdd（int[]nums）{
int-evenPos=0；
int oddPos=nums.length-1；
while（true）{
如果（evenPos>=oddPos | | evenPos>=nums.length | | oddPos遵守您的限制，这里有一个单循环答案：

public int[] evenOdd(int[] nums) {
    int[] result = new int[nums.length];
    int nextEven = 0;
    int nextOdd = nums.length - 1;

    for ( int num : nums )
    {
        if ( num % 2 == 0 )
            result[ nextEven++ ] = num;
        else
            result[ nextOdd-- ] = num;
    }

    return result;
}

根据您的限制，这里有一个单循环的答案：

public int[] evenOdd(int[] nums) {
    int[] result = new int[nums.length];
    int nextEven = 0;
    int nextOdd = nums.length - 1;

    for ( int num : nums )
    {
        if ( num % 2 == 0 )
            result[ nextEven++ ] = num;
        else
            result[ nextOdd-- ] = num;
    }

    return result;
}

好的！我最终跳过了这个事实上已经关闭的问题，但是asker的解决方案几乎已经解决了，除了在我修复的两个案例中失败之外：

我对asker的代码进行了注释，这使得它在几个案例中失败，如问题中所示

我认为以下是最简单、最优化的解决方案：

public int[] evenOdd(int[] nums) {
int y=nums.length,x,a=0;
int temp=0;

for(x=0;x<y;x++)
{
    if(nums[x]%2==0) {
    if(a>(y-2))
       return nums;
    else{
    //nums[a]=nums[a]+nums[x];
    //nums[x]=nums[a]-nums[x];
    //nums[a]=nums[a]-nums[x];

    temp=nums[a];
    nums[a]=nums[x];
    nums[x]=temp;
    a+=1; 
        }

    } 

    return nums; 

    }

public int[]evenOdd（int[]nums）{
int y=nums.长度，x，a=0；
内部温度=0；
对于（x=0；x（y-2））
返回nums；
否则{
//nums[a]=nums[a]+nums[x]；
//nums[x]=nums[a]-nums[x]；
//努姆斯
public int[] evenOdd(int[] nums) {
  List<Integer> evens = new ArrayList<Integer>(nums.length);
  List<Integer> odds = new ArrayList<Integer>(nums.length);
  for (int num : nums)
    if (isOdd(num)) odds.add(num);
    else evens.add(num);

  int[] results = new int[nums.length];
  int i = 0;
  for (int num : evens) results[i++] = num;
  for (int num : odds) results[i++] = num;
  return results;
}

boolean isOdd(int num) { return (num & 1) == 1; }