Java 将整数数组中前半部分的所有偶数和后半部分的奇数移动

我有一个面试问题，我无法解决

Java编程语言中的一种写方法（不是程序），它将整数数组中前半部分的所有偶数和后半部分的奇数移动

例如，输入={3,8,12,5,9,21,6,10}；输出={12,8,6,10,3,5,9,21}

该方法应将整数数组作为参数，并在同一数组中移动项（不要创建另一个数组）。数字的顺序可能与原始数组不同。这是算法测试，所以尽量给出有效的算法（可能是线性O（n）算法）。避免使用内置函数/API*

---

还有一些关于什么是数据结构效率的基本介绍保持两个索引：一个是第一个奇数，一个是最后一个偶数。交换这些数字并更新索引。

保留两个索引：一个是第一个奇数，一个是最后一个偶数。交换这些数字并更新索引。

是否会要求您实现一个非常基本的BubbleSort版本，其中元素e的排序值e=arr[i]，=e%2==1？1 : -1 ? 当做

---

Leon

是否要求您实现一个非常基本的BubbleSort版本，其中元素e的排序值，其中e=arr[i]，=e%2==1？1 : -1 ? 当做 Leon（在@manu fatto的建议的帮助下）我相信这可以做到：

private static int[] OddSort(int[] items)
{
    int oddPos, nextEvenPos;
    for (nextEvenPos = 0; 
         nextEvenPos < items.Length && items[nextEvenPos] % 2 == 0;
         nextEvenPos++) { }
    // nextEvenPos is now positioned at the first odd number in the array, 
    // i.e. it is the next place an even number will be placed

    // We already know that items[nextEvenPos] is odd (from the condition of the 
    // first loop), so we'll start looking for even numbers at nextEvenPos + 1
    for (oddPos = nextEvenPos + 1; oddPos < items.Length; oddPos++)
    {
        // If we find an even number
        if (items[oddPos] % 2 == 0)
        {
            // Swap the values
            int temp = items[nextEvenPos];
            items[nextEvenPos] = items[oddPos];
            items[oddPos] = temp;
            // And increment the location for the next even number
            nextEvenPos++;
        }
    }

    return items;
}

私有静态int[]OddSort（int[]items）
{
int oddPos，nextEvenPos；
对于（nextEvenPos=0；
nextEvenPos

该算法只遍历列表一次（检查每个元素一次），因此效率为O（n）。

（在@manu-fatto的建议的帮助下）我相信这可以做到：

private static int[] OddSort(int[] items)
{
    int oddPos, nextEvenPos;
    for (nextEvenPos = 0; 
         nextEvenPos < items.Length && items[nextEvenPos] % 2 == 0;
         nextEvenPos++) { }
    // nextEvenPos is now positioned at the first odd number in the array, 
    // i.e. it is the next place an even number will be placed

    // We already know that items[nextEvenPos] is odd (from the condition of the 
    // first loop), so we'll start looking for even numbers at nextEvenPos + 1
    for (oddPos = nextEvenPos + 1; oddPos < items.Length; oddPos++)
    {
        // If we find an even number
        if (items[oddPos] % 2 == 0)
        {
            // Swap the values
            int temp = items[nextEvenPos];
            items[nextEvenPos] = items[oddPos];
            items[oddPos] = temp;
            // And increment the location for the next even number
            nextEvenPos++;
        }
    }

    return items;
}

私有静态int[]OddSort（int[]items）
{
int oddPos，nextEvenPos；
对于（nextEvenPos=0；
nextEvenPos

该算法只遍历列表1次（检查每个元素一次），因此效率为O（n）。

publicstaticvoidsorted（int[]integer）{
int i，j，温度；
对于（i=0；i

答案是1,7,9,2,4。

公共静态void排序（int[]integer）{
int i，j，温度；
对于（i=0；i

---

答案是1,7,9,2,4。

//在一个for循环中执行此操作

public static void evenodd(int[] integer) {

    int i = 0, temp = 0;
    int j = integer.length - 1;

    while (j >= i) {
        // swap if found odd even combo at i and j
        if (integer[i] % 2 != 0 && integer[j] % 2 == 0) {
            temp = integer[i];
            integer[i] = integer[j];
            integer[j] = temp;
            i++;
            j--;

        } else {
            if (integer[i] % 2 == 0) {
                i++;
            }
            if (integer[j] % 2 == 1) {
                j--;
            }

        }

    }
} 

---

//在一个for循环中执行此操作

public static void evenodd(int[] integer) {

    int i = 0, temp = 0;
    int j = integer.length - 1;

    while (j >= i) {
        // swap if found odd even combo at i and j
        if (integer[i] % 2 != 0 && integer[j] % 2 == 0) {
            temp = integer[i];
            integer[i] = integer[j];
            integer[j] = temp;
            i++;
            j--;

        } else {
            if (integer[i] % 2 == 0) {
                i++;
            }
            if (integer[j] % 2 == 1) {
                j--;
            }

        }

    }
} 

类演示
{
公共空目录（int[]a）
{
int len=a.长度；
int j=len-1；
对于（int i=0；i（len/2）-1）
j--；
如果（j
class）演示
{
公共空目录（int[]a）
{
int len=a.长度；
int j=len-1；
对于（int i=0；i（len/2）-1）
j--；
如果（j@JLRishe

您的算法无法维持顺序。举个简单的例子，例如{1,5,2}，您将数组更改为{2,5,1}。我无法在您的帖子下方发表评论，因为我是新用户，没有声誉。
@JLRishe

private static void rearrange(int[] a) {
    int i,j,temp;
    for(i = 0, j = a.length - 1; i < j ;i++,j--) {
        while(a[i]%2 == 0 && i != a.length - 1) {
            i++;
        }
        while(a[j]%2 == 1 && j != 0) {
            j--;
        }
        if(i>j)
            break;
        else {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }       
}

你的算法无法维持顺序。举个简单的例子，例如{1,5,2}，你将把数组改为{2,5,1}。我无法在你的帖子下方发表评论，因为我是新用户，没有声誉。
私有静态无效重排（int[]a）{
private static void rearrange(int[] a) {
    int i,j,temp;
    for(i = 0, j = a.length - 1; i < j ;i++,j--) {
        while(a[i]%2 == 0 && i != a.length - 1) {
            i++;
        }
        while(a[j]%2 == 1 && j != 0) {
            j--;
        }
        if(i>j)
            break;
        else {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }       
}

int i，j，温度；
对于（i=0，j=a.length-1；ij）
打破
否则{
温度=a[i]；
a[i]=a[j]；
a[j]=温度；
}
}       
}
私有静态无效重新排列（int[]a）{
int i，j，温度；
为了
static void EvensToLeft(int[] items) {
    int end = items.length;
    for (int i = 0; i < end; i++) {
        if (items[i] % 2) {
            int t = items[i];
            items[i--] = items[--end];
            items[end] = t;
        }
    }
}

  public int[] evenOddSort(int[] a) {
        int i = 0;
        int j = a.length - 1;
        int temp;
        while (i < j) {
            if (a[i] % 2 == 0) {
                i++;
            } else if (a[j] % 2 != 0) {
                j--;
            } else {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
                i++;
                j--;
            }
        }
        return a;
    }

public static int[] seperatOddAndEvnNos(int[] listOfNumbers) {
    int oddNumPointer = 0;
    int evenNumPointer = listOfNumbers.length - 1;
    while(oddNumPointer <= evenNumPointer) {                
            if(listOfNumbers[oddNumPointer] % 2 == 0) { //even number, swap to front of last known even number
                int temp;
                temp = listOfNumbers[oddNumPointer];
                listOfNumbers[oddNumPointer] = listOfNumbers[evenNumPointer];
                listOfNumbers[evenNumPointer] = temp;
                evenNumPointer--;
            }
            else {  //odd number, go ahead... capture next element
                oddNumPointer++;
            }


    }
    return listOfNumbers;
}


public static void main(String[] args) {
    // TODO Auto-generated method stub
    int []arr = {3, 8, 12, 5, 9, 21, 6, 10};
    int[] seperatedArray = seperatOddAndEvnNos(arr);
    for (int i : seperatedArray) {
        System.out.println(i);
    }

}

public class TestProg {
public static void main(String[] args) {
    int[] input = { 32, 54, 35, 18, 23, 17, 2 };
    int front = 0;
    int mid = input.length - 1;
    for (int start = 0; start < input.length; start++) {
    //if current element is odd
        if (start < mid && input[start] % 2 == 1) {
    //swapping element is also odd?
            if (input[mid] % 2 == 1) {
                mid--;
                start--;
            } 
    //swapping element is not odd then swap
     else {
                int tmp = input[mid];
                input[mid] = input[start];
                input[start] = tmp;
                mid--;
            }
        }

    }
    for (int x : input)
        System.out.print(x + " ");
}

public static void main(String[] args) {
    int[] arr = generateTestData();
    System.out.println(Arrays.toString(arr));

    ArraysSortEvensFirst test = new ArraysSortEvensFirst();
    test.sortEvensFirst(arr);

}

private static int[] generateTestData() {
    int[] arr = {1,3,5,6,9,2,4,5,7};
    return arr;
}

public int[] sortEvensFirst(int[] arr) {
    int end = arr.length;

    int last = arr.length-1;
    for(int i=0; i < arr.length; i++) {
        // find odd elements, then move to even slots
        if(arr[i]%2 > 0) {
            int k = findEven(last, arr);
            if(k > i) swap(arr, i, k);
            last = k;
        }
    }

    System.out.println(Arrays.toString(arr));
    return arr;
}

public int findEven(int last, int[] arr) {
    for(int k = last; k > 0; k--) {
        if(arr[k]%2 == 0) {
            return k;
        }
    }
    return -1; // not found;
}

public void swap(int[] arr, int x, int y) {
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
}