荷兰国旗问题

给定一个数组arr和一个数 num，请把小于等于num的数放在数组的左边，
 大于num的数放在数组的右边。
 额外要求空间复杂度0(1),时间复杂度0(N) 

分析：

    /**
     *
     * @param arr 给定的数组
     * @param num   给定的数
     */
    public static void group(int[] arr,int num){
        int mix=-1;
        int temp=0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<num){
                mix++;
                temp=arr[i];　　　　这里不能使用 位运算 因为 mix++ =0 
                arr[i]=arr[mix];
                arr[mix]=temp;
            }
        }
    }

 

问题二：（荷兰国旗问题）

　　给定一个数组 arr 和一个数 num ,请把小于 num的数放在数组的左边，等于 num 的数放在数组的 中间，大于num的数放在数组的右边。

　　要求额外空间复杂度 O(1)，时间复杂度 O(N)

 

    /**
     * 荷兰国旗问题
     *
     * @param num
     */
    public static void helan(int[] arr, int num) {
        int less=-1;        //最小范围
        int more=arr.length;    //最大范围
        int cur=0;          //记录当前位置
        while (cur<more){       //当前位置小于最大位置
            if(arr[cur]<num){       //当前位置 < 目标数
                swap(arr,++less,cur++);     //将最小范围加1，再将当前位置加一
            }else if(arr[cur]==num){        //如果当前位置数 = 目标位置
                cur++;              //当前位置 +1
            }else {
                swap(arr,--more,cur);       //当前位置 > 目标数 （将最大范围-1，当前位置不变）
            }
        }
    }
    /**
     * 数组交换
     */
    public static void swap(int[] arr,int l,int cur){
        int temp=0;
        temp=arr[cur];
        arr[cur]=arr[l];
        arr[l]=temp;
    }

 

public class 荷兰国旗 {

    @Test
    public void test() {
        int[] ints = {3, 5, 6, 8, 8, 6, 12, 2, 4, 1, 45};
        int[] intsd = sorts(ints, 8,0,ints.length-1);
        System.out.println(Arrays.toString(intsd));
    }

    /**
     * 荷兰国旗问题
     * @param ints 需要交换的数组
     * @param key 目标值
     * @param les 指定范围（最小范围）
     * @param mores 指定范围（最大范围）
     * @return
     */
    private int[] sorts(int[] ints, int key,int les,int mores) {
        int less =les-1;
        int more =mores+1;
        int cur = les;
        while (cur < more) {
            if (key == ints[cur]) {
                cur++;
            } else if (key > ints[cur]) {
                swap(ints, cur++, ++less);
            } else {
                swap(ints,cur,--more);
            }
        }
        return ints;
    }

    private void swap(int[] ints, int swap, int index) {
        int temp = ints[swap];
        ints[swap] = ints[index];
        ints[index] = temp;
    }

}