《剑指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];
         }
     }