【剑指offer】把一个数组分为两部分

问题描述

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分

解题思路

我们可以设置两个指针 lo,hi，分别从头部向尾部移动，从尾部向头部移动，当 a[lo] 为偶数，并且 a[hi] 为奇数时，将他们交换；这种解法时间复杂度 为 O（n );

    private static void reOrderArray2(int[] a) {
        int lo = 0;
        int hi = a.length - 1;
        while(lo < hi) {
            //从左边循环找到一个偶数           
            while(lo < a.length && (a[lo] & 1) != 0)
                lo++;
            //从右边循环找到一个奇数
            while(hi >= 0 && (a[hi] & 1) != 1) 
                hi--;
            //交换
            if(lo < hi){
                int temp = a[hi];
                a[hi] = a[lo];
                a[lo] = temp;
                lo++;
                hi--;
            }
        }
    }

如何这个问题是把数组分为左边的是能被3整除的，右边是不能被3整除的，或者，左边是大于3的，右边是小于3的，这些条件的话，为了提高代码的适应能力，我们可以把判断条件单独抽出来，写成一个接口，当我们需要调用的时候再把接口实现传进去；

public class DoubleExp {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6,7,8,9,10};
        //需要让这个方法按照什么条件执行，就在实现接口的时候实现
        reOrderArray5(a,new Judge() {
            @Override
            public boolean doJudge(int a) {
                return (a & 1) == 1;

            }
        });
        for(int i : a) 
            System.out.print(" " + i);
    }


    private static void reOrderArray5(int[] a,Judge judge) {
        if (a == null || a.length == 0) return;
        int lo = 0;
        int hi = a.length - 1;
        while(lo < hi) {
            //从左边开始找到一个偶数           
            while(lo < a.length && judge.doJudge(a[lo]))
                lo++;
            //从右边开始找到一个奇数
            while(hi >= 0 && !judge.doJudge(a[hi])) 
                hi--;
            if(lo < hi){
                int temp = a[hi];
                a[hi] = a[lo];
                a[lo] = temp;
                lo++;
                hi--;
            }
        }
    }

    //这个接口实现判断功能
    public interface Judge{
        boolean doJudge(int a);
    }
}

问题进阶

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

解题思路

要保证各数字之间的相对位置的话，我们很容易想到，开辟一个同等大小的数组 a，从头到尾循环两次整个数组，第一次把所有奇数存到 a 中，那么前半部分就都是奇数了，而且奇数的相对位置不变，第二次循环把偶数存到数组 a 中。这种方法时间复杂度为 O( n )，空间复杂度也为 O(N);

    public void reOrderArray(int [] array) {
        int[] z = new int[array.length];
        int j = 0;
        for(int i = 0; i < array.length; i++) {
            if((array[i] & 1) == 1 ) 
                z[j++] = array[i];
        }
        for(int i = 0; i < array.length; i++) {
            if((array[i] & 1) == 0) 
                z[j++] = array[i];
        }
        for(int i = 0; i < array.length; i++)
            array[i] = z[i];
    }

空间复杂度为 O （1） 的方法

利用插入排序的思想，维护一个下标 i ，使得 i 的左边都是奇数，再利用一个变量 j 向右移动，找到一个奇数，就将 i 到 j - 1 之间的数，向右移动一位，把 a[j] 插到 a[i] 上，并且更新 j = j + 1 或者 j = i + 1 ( 这种情况在注释中解释)；
这中方法时间复杂度是 O（n * n）;

    public static void reOrderArray1(int[] array) {
        int j = 0;
        /**
         * 维护i左边的都是奇数，
         * 
         * */       
        for(int i = 0; i < array.length; i++) {
            //找到一个偶数，它的坐标是i
            if((array[i] & 1) == 1) continue;
            //j是用来找奇数的，j前面的都是被找过 了的，所以每次继续找都是从j+1开始,
            //但如果像1，1，1，1，2，3这种序列，i一开始就比j大，所以j = i + 1;
             j = i > j ? i + 1 : j+ 1;
             //找到一个奇数
            for(; j < array.length; j++) {
                if((array[j] & 1) == 1) break;
            }
            if(j < array.length)
                exchange(array,i,j);
        }
    }
    private static void exchange(int[] a,int i,int j) {
        int key = a[j];
        while(j > i) {
            a[j] = a[j - 1];
            j--;
        }
        a[i] = key;
    }