剑指offer(十二，十三) 数值的整数次方，调整数组顺序使奇数位于偶数前面

1.数值的整数次方

***时间限制：1秒 空间限制：32768K ***
题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

标准的快速幂。。。注意base为0 return 0，我用JS抛出错误在oj上错了 QAQ
还有就是负数的情况，变正，然后倒回来。
其实这个base是double类型，C++里面的话不能直接比较，需要写个abs

    boolean equal(double num1,double num2){
        if(num1-num2>-0.000001&&num1-num2<0.000001)
            return true;
        else
            return false;
    }

我用js写就先不考虑这个问题了。
还有就是快速幂的思想了，其实就是二进制化再重组答案，重组答案的时候底数是新base。
时间复杂度是二进制的长度，也就是logn。（参考二叉树的深度）

/*
2^11 = 2^1 * 2^2 * 2^8
2^1011 = 1* 2^0001 + 1* 2^0010 + 0*2^0000 +1* 2^1000

11 = 1011(2)
1*x^8 + 0*x^4 + 1*x^2 + 1*x
x是底数，分解二进制 -> 根据新底数重组答案(底数不是2了)
*/
function Power(base, exponent)
{
    p = exponent;
    if(base==0) return 0;
    else if(p==0) return 1;
    else if(p<0)
        p = -p;//变正
    var ans = 1;
    while(p) {
        // console.log(p);
        if(p&1) {
            ans *= base;
        }
        base*=base;//相应的基数自乘
        p = p>>1;//遍历二进制下的每一位
    }
    return exponent>0?ans:1/ans;
}

console.log(Power(2, 3));

2.调整数组顺序使奇数位于偶数前面

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

看到这道题我就想到了排序的思想，这道题也就是排序的变种，只不过这里重新制定了排序的规则而已，不是常规的降序或者升序。

两个方向，时间换空间，空间换时间。

时间换空间

可以利用插排思想和冒泡排序思想，时间换空间下也有两种方法。

1.在原数组上操作，插入排序的思想，制定两个指针，i和j，i从前面扫面找到第一个偶数，j从i+1开始扫描找到第一个奇数，把i.......j-1往后移动一个位置，提前保存好tmp=array[j]，把j位置上的tmp插到i位置，完成交换。
eg：
1 2 4 6 7
i j
->交换后
1 7 2 4 6，因为j是i+1的，如果i找不到j也就找不到了（i会到len），利用这个判断边界。

function reOrderArray(array)
{
    if(array.length==0) return [];
    var len = array.length;
    var i = 0;
    while(i<len) {
        while (i < len && judge_q(array[i])) i++;
        var j = i + 1;
        while (j < len && !judge_q(array[j])) j++;
        if (j < len) {
            var tmp = array[j];
            for (var k = j; k > i; k--) {
                array[k] = array[k - 1];
            }
            array[i] = tmp;
        }else {
            break;
        }
    }
    return array;
}

function judge_q(a) {
    if(a&1) return true;
    else return false;
}

var b = [1,2,4,6,7];
console.log(reOrderArray(b));

时间复杂度O(N^2)，当然空间上省了很多。（没开第三方数组）

2.理解上面的，肯定就会想到用冒泡排序的思想来做了

//C++
for (int i = 0; i < array.size();i++)
{
    for (int j = array.size() - 1; j>i;j--)
    {
        if (array[j] % 2 == 1 && array[j - 1]%2 == 0) //前偶后奇交换
        {
            swap(array[j], array[j-1]);
        }
    }
}

也是O(N^2)的复杂度

空间换时间

O(n)线性时间复杂度，空间上多开一个数组。

function reOrderArray(array)
{
    var ans_q = [];
    var ans_o = [];
    for(var i = 0; i <array.length; i++) {
        if(array[i]&1) {
            ans_q.push(array[i]);
        }
        else {
            ans_o.push(array[i]);
        }
    }
    return ans_q.concat(ans_o);
}