数组a中存放了十个数，要求调用函数将数组重新排列，排列的方法是将奇数放在数组的左边，偶数放在数组的右边。

可以定义两个指针，一个指向数组的开始位置，一个指向数组的末尾位置。然后，分别从两个方向向中间扫描，如果左边的数字是偶数，右边的数字是奇数，则交换两个数字的位置。直到两个指针相遇为止。下面是具体的代码实现：

void reorder(int* a, int length)
{
    if(a == NULL || length <= 0)
        return;
        
    int *pBegin = a;
    int *pEnd = a + length - 1;
    
    while(pBegin < pEnd)
    {
        while(pBegin < pEnd && (*pBegin & 0x1) != 0)
            pBegin++;
        
        while(pBegin < pEnd && (*pEnd & 0x1) == 0)
            pEnd--;
        
        if(pBegin < pEnd)
        {
            int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;
        }
    }
}

这个函数的时间复杂度是 O(n)，空间复杂度是 O(1)。

相关问题

数组a中存放了十个整数要求调用函数将数组a中的数重新排序排列的方法是将偶数放在数组的左边奇数放在数组的右部

好的，根据您的要求，我可以提供一个简单的方法来重新排序数组a，使得偶数在左边，奇数在右边。以下是示例代码：

def sort_array(a):
    left, right = 0, len(a) - 1
    while left < right:
        while a[left] % 2 == 0 and left < right:
            left += 1
        while a[right] % 2 != 0 and left < right:
            right -= 1
        if left < right:
            a[left], a[right] = a[right], a[left]
            left += 1
            right -= 1

这个函数使用双指针的方法，从数组的两端开始扫描，如果左侧指针指向的元素是偶数，则向右移动左侧指针；如果右侧指针指向的元素是奇数，则向左移动右侧指针；如果左侧指针指向的元素是奇数，右侧指针指向的元素是偶数，则交换这两个元素。最终，所有偶数都被放到了数组的左边，所有奇数都被放到了数组的右边。

实验二: 数组a中存放了10个正整数，要求调用函数将数组a中的数重新排列。排列的方法是将偶数放在数组的左部，奇数放在数组的右部。 例如: 原数组:21 34 224 25 367 41 736 37 42 456重排后:34 224 736 42 456 37 41 367 25 21

好的，这是一个简单的数组操作问题。可以按照以下步骤来解决：

1. 定义一个函数，接收一个整数数组和数组的长度作为参数。

2. 定义两个指针，一个指向数组的开头，一个指向数组的结尾。

3. 从开头开始遍历数组，如果遇到偶数就继续向后移动指针，直到找到奇数。

4. 从结尾开始遍历数组，如果遇到奇数就继续向前移动指针，直到找到偶数。

5. 如果找到了奇数和偶数，则交换它们的位置，继续执行步骤3和4，直到指针相遇。

6. 函数返回排序后的数组。

下面是示例代码：

void reorder(int a[], int len) {
    int *p1 = a;
    int *p2 = a + len - 1;
    while (p1 < p2) {
        while (p1 < p2 && *p1 % 2 == 0) p1++;
        while (p1 < p2 && *p2 % 2 == 1) p2--;
        if (p1 < p2) {
            int tmp = *p1;
            *p1 = *p2;
            *p2 = tmp;
        }
    }
}

int main() {
    int a[] = {21, 34, 224, 25, 367, 41, 736, 37, 42, 456};
    int len = sizeof(a) / sizeof(int);
    reorder(a, len);
    for (int i = 0; i < len; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}

输出结果为：34 224 736 42 456 37 41 367 25 21