《剑指offer》算法题第四天

今日题目：

1. 二进制中1的个数
2. 数值的整数次方
3. 调整数组顺序使奇数位于偶数前面
4. 链表中倒数第K个节点
5. 链表中环的入口节点

今天的题目都比较简单，但是前三道题都有不同的解法，4,5两题就不在这边讨论了，其中第五道题大家可以了解一下floyd判圈算法。

1. 二进制中1的个数

题目描述：
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

解法一：

    public int NumberOf1(int n) {
 
        int res = 0, count = 32;
        while(count-- > 0){
            if((n&1) == 1)
                res++;
            n = n >> 1;
        }
        return res;
    }

解法二，这个解法要由于解法一，循环的次数为1出现的次数：

    public int NumberOf1(int n) {
 
        int res = 0;
        while(n != 0){
            res++;
            n = (n-1)&n;
        }
        return res;
    }

2. 数值的整数次方

题目描述：
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

这题需要考虑到的是exponent为负数时的情况，其他的并不复杂，下面给出递归和迭代的解法。

解法一，递归：

    public double Power(double base, int exponent) {
        if(exponent < 0){
            exponent *= -1;
            base = 1/base;
        }
        return power(base,exponent);
  }
     
    public double power(double m, int n){
        if(n == 0)
            return 1;
        if(n == 1)
            return m;
        double res = power(m,n>>1);
        res *= res;
        if((n&1) == 1)
            res *= m;
        return res;
    }

解法二，迭代：

public double Power(double base, int exponent) {
        if(exponent < 0){
            exponent *= -1;
            base = 1/base;
        }
           double res = 1.0;
        while(exponent != 0){
            if((exponent&1) == 1)
                res *= base;
            base *= base;
            exponent >>= 1;
        }
        return res;
  }

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

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

这道题本身不难，通过数组常见的操作就能实现，但是牛客网相对于书上而言多了一个条件，就是要保证相对位置不变，因此考虑使用插入排序和冒泡排序的思想来实现，因为它们都是稳定排序，可以确保相对位置的不变。

解法一，利用排序实现，时间复杂度为O(n²)

//冒泡排序
    public void reOrderArray(int [] array) {
        if(array.length < 2)
            return;
        for(int i = 0; i < array.length; i++){
            for(int j = array.length-1; j > i; j--){
                if((array[j-1]&1) == 0 && (array[j]&1)==1){
                    int tmp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = tmp;
                }
            }
        }
        
    }

//插入排序
    public void reOrderArray(int [] array) {
        if(array.length < 2)
            return;
        for(int i = 1; i < array.length; i++){
            if((array[i]&1) == 1){
                int tmp = array[i];
                int j = i-1;
                for(;j >= 0 && (array[j]&1)==0; j--)
                    array[j+1] = array[j];
                array[j+1] = tmp;
                 
            }
        }
         
    }

解法二，以空间换时间，复杂度均为O(n)：

    public void reOrderArray(int [] array) {
        if(array.length==0||array.length==1) return;
        int oddCount=0,oddBegin=0;
        int[] newArray=new int[array.length];
        for(int i=0;i<array.length;i++){
            if((array[i]&1)==1) oddCount++;
        }
        for(int i=0;i<array.length;i++){
            if((array[i]&1)==1) newArray[oddBegin++]=array[i];
            else newArray[oddCount++]=array[i];
        }
        for(int i=0;i<array.length;i++){
            array[i]=newArray[i];
        }
    }