创建一个顺序表 存放在数组a[n]中，元素的类型为整型，设计算法调整

顺序表的元素顺序，使得所有奇数在前面，所有偶数在后面。

算法如下：

1. 定义两个指针i和j，分别指向数组的第一个元素和最后一个元素。

2. 当i<j时，执行以下操作：

a. 如果a[i]为奇数，则i++，继续向后遍历。

b. 如果a[j]为偶数，则j--，继续向前遍历。

c. 如果a[i]为偶数，a[j]为奇数，则交换a[i]和a[j]的值，然后i++，j--，继续向后、向前遍历。

3. 当i>=j时，遍历结束，顺序表的元素顺序已经调整完毕。

代码实现如下：

void adjust(int a[], int n)
{
int i = , j = n - 1;
while (i < j)
{
if (a[i] % 2 == 1) // 如果a[i]为奇数，则i++，继续向后遍历
i++;
else if (a[j] % 2 == ) // 如果a[j]为偶数，则j--，继续向前遍历
j--;
else // 如果a[i]为偶数，a[j]为奇数，则交换a[i]和a[j]的值，然后i++，j--，继续向后、向前遍历
{
int temp = a[i];
a[i] = a[j];
a[j] = temp;
i++;
j--;
}
}
}

相关问题

创建一个顺序表，存放在数组 a[n]中，元素的类型为整型，设计算法调整 a，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空 间复杂度均为 o(n)）。

### 回答1：
可以使用双指针法来实现该算法。具体步骤如下：

1. 定义两个指针 left 和 right，分别指向数组的第一个元素和最后一个元素。

2. 当 left 指向的元素小于 0 时，left 向右移动一位。

3. 当 right 指向的元素大于 0 时，right 向左移动一位。

4. 如果 left 和 right 指向的元素都不满足上述条件，则交换它们的值，并将 left 向右移动一位，right 向左移动一位。

5. 重复步骤 2-4，直到 left 和 right 相遇。

6. 此时，数组中所有小于 0 的元素都在 left 左边，所有大于 0 的元素都在 right 右边。

该算法的时间复杂度为 O(n)，空间复杂度为 O(1)。

### 回答2：
可以采用双指针算法来实现要求。

首先，我们定义两个指针left和right，分别指向数组的头部和尾部。

然后，不断进行如下操作：

1. 当a[left]小于0时，left指针右移一位；
2. 当a[right]大于0时，right指针左移一位；
3. 如果left指针仍然小于right指针，交换a[left]和a[right]的值；
4. 重复1-3步骤，直到left指针不小于right指针。

最终，当left指针不小于right指针时，所有左边元素都小于0，右边元素都大于0。

该算法的时间复杂度和空间复杂度均为O(n)，因为只需遍历一次数组即可完成调整。

以下是代码示例：

def adjust_array(a):
    left = 0
    right = len(a)-1

    while left < right:
        while a[left] < 0:
            left += 1
        while a[right] > 0:
            right -= 1

        if left < right:
            a[left], a[right] = a[right], a[left]

    return a

调用该函数，可以得到调整后的数组。

### 回答3：
算法思路：
将数组分为左右两部分，左边部分存放小于0的元素，右边部分存放大于0的元素。首先需要找到第一个大于0的元素的下标，然后将小于0的元素依次向前移动，并将大于0的元素放到数组的尾端。

算法步骤：
1. 初始化两个指针left和right，分别指向数组的第一个和最后一个元素。
2. 移动left指针，直到找到第一个大于等于0的元素。
3. 移动right指针，直到找到第一个小于0的元素。
4. 如果left < right，则交换left和right指向的元素，并分别将left和right指针向后、向前移动一位。
5. 重复步骤4，直到left >= right。
6. 此时，left左边的元素都小于0，right右边的元素都大于0。

时间复杂度和空间复杂度分析：
该算法只需要遍历一次数组，因此时间复杂度为O(n)。同时只使用了常数个辅助变量，因此空间复杂度也为O(1)。

代码实现：

void adjustArray(int a[], int n) {
    int left = 0;
    int right = n - 1;
    
    while (left < right) {
        while (left < right && a[left] < 0) {
            left++;
        }
        
        while (left < right && a[right] >= 0) {
            right--;
        }
        
        if (left < right) {
            int temp = a[left];
            a[left] = a[right];
            a[right] = temp;
            left++;
            right--;
        }
    }
}

创建一个顺序表，存放在数组 a[n]中，元素的类型为整型，设计算法调整\r\na，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空\r\n间复杂度均为 o(n)）。

算法步骤如下：

1. 定义两个指针 i 和 j，分别指向数组的第一个元素和最后一个元素。

2. 当 i < j 时，执行以下操作：

a. 如果 a[i] < ，则 i++。

b. 如果 a[j] > ，则 j--。

c. 如果 a[i] >= 且 a[j] <= ，则交换 a[i] 和 a[j]。

3. 当 i >= j 时，算法结束。

时间复杂度为 O(n)，空间复杂度为 O(1)。