调整数组顺序使奇数位于偶数前面(一)

void bubble_swap(int* array, int len) 
{
    for(int i=len-2;i>=0;i--)
    {
        for(int j=i;j<len-1;j++)
        {
            if(array[j]%2==0 && array[j+1]%2!=0)
            {
                int tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
            }
        }
    }
}
int* reOrderArray(int* array, int arrayLen, int* returnSize ) {
    // write code here
    *returnSize = 0;
    if(array == NULL || arrayLen == 0)
        return NULL;
    bubble_swap(array,arrayLen);
    *returnSize = arrayLen;
    return array;

}

进阶一步到位
int* reOrderArray(int* array, int arrayLen, int* returnSize ) {
    // write code here
    int temp;
    for(int i=0;i<arrayLen;i++){
        if(i<0) i=0;
        if(array[i]%2==0){
            if(i==arrayLen) break;    //若已排查到最后一个仍为偶数，则表明替换完成
            if(array[i+1]%2==1){      //若当前为偶数，但是下一个为奇数，则二者交换
                temp=array[i];
                array[i]=array[i+1];
                array[i+1]=temp;
                i=i-2;                //把指针放到刚才替换的这个偶数的前一个，解决连着都是偶数的情况
            }
        }
    }
    *returnSize=arrayLen;
    return array;
}

typedef struct SL//定义一个结构体模板
{
    int* vate;//int指针/数组
    int size;//实际数位计数
    int capecity;//空间大小
}SL;

void init(SL* tr)//初始化
{
    tr->vate = NULL;
    tr->capecity = tr->size = 0;
}

void rea_cp(SL* tr)//扩容
{
    int new_capecity = tr->capecity == 0 ? 4 : tr->capecity * 2;
    int* tep = (int*)realloc(tr->vate, sizeof(int)*new_capecity);
    tr->vate = tep;
    tr->capecity = new_capecity;
}

int* reOrderArray(int* array, int arrayLen, int* returnSize ) 
{
    // write code here
    SL tr_1, tr_2;//声明两个结构体对象
    init(&tr_1);//初始化两个结构体
    init(&tr_2);
    for(int i = 0; i<arrayLen; i++)//区分
    {
        if(array[i] % 2 == 0)//偶数放在tr_2中
        {
            if(tr_2.size == tr_2.capecity)//检查空间
            {
                rea_cp(&tr_2);
            }
            tr_2.vate[tr_2.size++] = array[i];
        }
        else//奇数放在tr_1中
        {
            if(tr_1.size == tr_1.capecity)//检查空间
            {
                rea_cp(&tr_1);
            }
            tr_1.vate[tr_1.size++] = array[i];
        }
    }
    if(tr_2.size == arrayLen)//若偶数组等于原数组数位，则代表全是偶数，返回
    {
        *returnSize = tr_2.size;
        return tr_2.vate;
    }
    if(tr_1.size == arrayLen)//若基数组等于原数组数位，则代表全是奇数，返回
    {
        *returnSize = tr_1.size;
        return tr_1.vate;
    }
    for(int j = 0; j < tr_2.size; j++)//如果不是以上，则将偶数组元素插入倒奇数组后
    {
        if(tr_1.size == tr_1.capecity)//检查扩容
        {
            rea_cp(&tr_1);   
        }
        tr_1.vate[tr_1.size++] = tr_2.vate[j];//倒数
    }
    *returnSize = tr_1.size;//返回
    return tr_1.vate;
}

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param array int整型一维数组 
 * @param arrayLen int array数组长度
 * @return int整型一维数组
 * @return int* returnSize 返回数组行数
 */
int* reOrderArray(int* array, int arrayLen, int* returnSize ) {
    // write code here
    *returnSize = 0;
    if(arrayLen == 0) return NULL;
    int *Retarray = (int*)malloc(arrayLen*sizeof(int));
    memset(Retarray, 0, arrayLen);
    
    for(int i = 0; i < arrayLen; i++)
    {
        if(array[i] % 2 == 1) 
        {
            Retarray[*returnSize] = array[i];
            *returnSize = *returnSize + 1;
        }
    }
    
    for(int i = 0; i < arrayLen; i++)
    {
        if(array[i] % 2 == 0) 
        {
            Retarray[*returnSize] = array[i];
            *returnSize = *returnSize + 1;
        }
    }
    return Retarray;
}

int* reOrderArray(int* array, int arrayLen, int* returnSize ) {
  int* ans = (int*) malloc(arrayLen * sizeof(int));
  *returnSize = 0;
  if (!ans) return NULL;
  
  int i;
  for (i = 0; i < arrayLen; ++i)
    if (array[i] & 1) *(ans + (*returnSize)++) = array[i];
  
  for (i = 0; i < arrayLen; ++i)
    if (array[i] % 2 == 0) *(ans + (*returnSize)++) = array[i];
  
  return ans;
}