输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

/**
 * 输入一个整数数组，
 * 实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，
 * 并保证奇数和奇数，偶数和偶数之间的相对位置不变。
 * 解：利用排序算法的稳定性来解
 */

public class Solution4 {

    

public static void main(String[] args) {
    int[] i = new int[]{9, 22, 23, 24, 14, 15, 16, 17, 6, 10, 11, 12};
    int[] n = mergeSort(i, new int[i.length], 0, i.length - 1);
    for (int k : n) {
        System.out.print(k + ",");
    }

}

    /**
     * 冒泡
     *
     * @param arrays
     * @return
     */
    public static int[] solution(int[] arrays) {
        if (null == arrays || 0 == arrays.length)
            return arrays;

        int[] newrrays1 = new int[arrays.length];
        int[] newrrays2 = new int[arrays.length];
        int j = 0, o = 0;
        for (int a : arrays) {
            if (0 != a % 2)
                newrrays1[j++] = a;
            else
                newrrays2[o++] = a;
        }
        int k = 0;
        while (k < j) {
            arrays[k] = newrrays1[k++];
        }

        int g = 0;
        while (g < o) {
            arrays[k++] = newrrays2[g++];
        }

        return arrays;
    }

    /**
     * @param arrays
     * @return
     */
    public static int[] mergeSort(int[] arrays, int[] copyarrays, int left, int right) {
        int length = right - left + 1;
        if (null == arrays || 1 >= length)
            return arrays;

        if (length == 2) {//长度为2的时候进行排序
            merge(arrays, copyarrays, left, right);
            return arrays;
        }

        int mid = (left + right) / 2;
        //left sort
        mergeSort(arrays, copyarrays, left, mid);
        //right sort
        mergeSort(arrays, copyarrays, mid + 1, right);
        //merge
        merge(arrays, copyarrays, left, right);

        return arrays;
    }

    public static void merge(int[] l, int[] c, int left, int right) {
        int length = right - left + 1;
        if (length == 2) {//奇偶位置相反时候进行排序
            int tmp;
            if (0 == l[left] % 2 && 0 != l[right] % 2) {
                tmp = l[left];
                l[left] = l[right];
                l[right] = tmp;
            }
            return;
        }
        int mid = (left + right) / 2;//合并数组的中间索引值
        int lborder = mid;//左数组的右边界
        int rborder = right;//右数组的右边界

        int le = left;//左数组起始指针
        int ri = mid + 1;//右数组起始指针
        int cleft = left;//临时数组起始指针

        while (cleft <= right) {//合并操作
            if (le > lborder) {
                //right into c
                while (ri <= rborder)
                    c[cleft++] = l[ri++];
                break;
            }
            if (ri > rborder) {
                //left into c
                while (le <= lborder)
                    c[cleft++] = l[le++];
                break;
            }

            if (0 != l[le] % 2)
                c[cleft++] = l[le++];
            else if (0 != l[ri] % 2)
                c[cleft++] = l[ri++];
            else
                c[cleft++] = l[le++];

        }

        while (left <= right) {//将合并完的结果覆盖原来数据段
            l[left] = c[left++];
        }

    }
}