剑指offer(11-15)

11.位运算：二进制中1的个数

题目描述：
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
法一：
解法思路：
设置标志数flag = 1，逐次右移1所在的位置，将flag与输入整数进行按位与运算，即可比较出输入整数与flag中当前1所对应的位置是否为0；

class Solution {
public:
     int  NumberOf1(int n) {
         int count = 0;
         int flag = 1;
         while (flag) {
             if (flag & n)
                 count++;
             flag = flag << 1;
         }
         return count;
     }
};

法二：
解法思路：
如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。

class Solution {
public:
     int  NumberOf1(int n) {
         int count = 0;
         while (n != 0) {
             count++;
             n = n & n-1;
         }
         return count;
     }
};

12.代码的完整性：数值的整数次方

题目描述：
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
解法思路：
法一：直接调用库函数pow()；

class Solution {
public:
    double Power(double base, int exponent) {
        return pow(base, exponent);
    }
};

法二：快速幂算法
算法思路：快速求幂算法
快速求正整数次幂，当然不能直接死乘。举个例子：
3 ^ 999 = 3 * 3 * 3 * … * 3
直接乘要做998次乘法。但事实上可以这样做，先求出2^k次幂：
3 ^ 2 = 3 * 3
3 ^ 4 = (3 ^ 2) * (3 ^ 2)
3 ^ 8 = (3 ^ 4) * (3 ^ 4)
3 ^ 16 = (3 ^ 8) * (3 ^ 8)
3 ^ 32 = (3 ^ 16) * (3 ^ 16)
3 ^ 64 = (3 ^ 32) * (3 ^ 32)
3 ^ 128 = (3 ^ 64) * (3 ^ 64)
3 ^ 256 = (3 ^ 128) * (3 ^ 128)
3 ^ 512 = (3 ^ 256) * (3 ^ 256)
再相乘：
3 ^ 999= 3 ^ (512 + 256 + 128 + 64 + 32 + 4 + 2 + 1)
= (3 ^ 512) * (3 ^ 256) * (3 ^ 128) * (3 ^ 64) * (3 ^ 32) * (3 ^ 4) * (3 ^ 2) * 3
这样只要做16次乘法。即使加上一些辅助的存储和运算，也比直接乘高效得多（尤其如果这里底数是成百上千位的大数字的话）。
我们发现，把999转为2进制数：1111100111，其各位就是要乘的数。这提示我们利用求二进制位的算法（其中mod是模运算）：

REVERSE_BINARY(n)1 
while (n > 0)
	 do output (n mod 2) 
	 	n ← n / 2

这个算法给出正整数n的反向二制进位，如6就给出011（6的二进制表示为110）。事实上这个算法对任意的p进制数是通用的，只要把其中的2换成p就可以了。
如何把它改编为求幂运算？我们发现这个算法是从低位向高位做的，而恰好我们求幂也想从低次幂向高次幂计算（参看前面的例子）。而且我们知道前面求出的每个2^k次幂只参与一次乘法运算，这就提示我们并不把所有的中间结果保存下来，而是在计算出它们后就立即运算。于是，我们要做的就是把输出语句改为要做的乘法运算，并在n减少的同时不断地累积
求2^k次幂。
还是看算法吧：

POWER_INTEGER(x, n)
1	pow ← 1
2	while (n > 0)
3	do if (n mod 2 = 1)
4		then pow ← pow * x
5	x ← x * x
6	n ← n / 2
7	return pow

不难看出这个算法与前面算法的关系。
在第1步给出结果的初值1，在while循环内进行运算。
3、4中的if语句就来自REVERSE_BINARY的输出语句，不过改成了如果是1则向pow中乘。
5句则是不断地计算x的2^k次幂，
如对前面的例子就是计算
2^2、
2^4、
2^8、
…、2^512。
应该指出，POWER_INTEGER比前面分析的要再多做两次乘法：
一次是向pow中第一次乘x，如2^1也要进行这个乘法；
另一次则是在算法的最后，n除以2后该跳出循环，而前面一次x的自乘就浪费掉了（也可以考虑改变循环模式优化掉它）。
另外，每趟while循环都要进行一次除法和一次模运算，这多数情况下除法和模运算都比乘法慢许多，不过好在我们往往可以用位运算来代替它。
相应的C++代码如下：

class Solution {
public:
    double Power(double base, int exponent) {
        long long p = abs((long long) exponent);
        double r = 1.0;
        while (p > 0) {
            if ((p % 2) == 1)
                r *= base;
            base *= base;
            p /= 2;
        }
        return (exponent < 0) ? 1/r : r;
    }
};

优化后如下：

class Solution {
public:
    double Power(double base, int exponent) {
        long long p = abs((long long) exponent);
        double r = 1.0;
        while (p) {
            if (p & 1)                //等价于(p % 2) == 1
                r *= base;
            base *= base;
            p >>= 1;                //等价于p /= 2;
        }
        return (exponent < 0) ? 1/r : r;
    }
};

13.代码的完整性：调整数组顺序使奇数位于偶数前面

题目描述：
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
法一：
解法思路：
新建立一个数组，
从前往后遍历原数组，将奇数从前往后存到新数组；
从后往前遍历旧数组，将偶数从后往前存到新数组；
随后将新数组元素依次转存到旧数组即可。

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        int len = array.size();
        int temp[len];
        int i_odd = 0;
        int i_even = array.size() - 1;
        for (int i = 0; i < array.size(); i++) {
            if ((array[i] % 2) != 0)
                temp[i_odd++] = array[i];
        }
        for (int j = array.size() - 1; j >= 0;j--) {
            if ((array[j] % 2) == 0)
                temp[i_even--] = array[j];
        }
        for (int i = 0; i < array.size(); i++)
            array[i] = temp[i];
    }
};

法二：
解法思路：
类似冒泡，前偶后奇就交换。

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        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]);
            }
        }
    }
};

14.代码的鲁棒性：链表中倒数第k个结点

题目描述：
输入一个链表，输出该链表中倒数第k个结点。
解法思路：
前后指针法。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if (!pListHead)
            return NULL;
        ListNode* front = pListHead;
        ListNode* later = pListHead;
        for (int i = 0; i < k-1; i++) {
            if (!front->next)
                return NULL;
            else
                front = front->next;
        }
        while (front->next){
            front = front->next;
            later = later->next;
        }
        return later;
    }
};

15.代码的鲁棒性：反转链表

题目描述：
输入一个链表，反转链表后，输出新链表的表头。
算法思想：
指针操作，主要是操作顺序问题：
（1）保护下一个指针：p_next = p->next；
（2）当前指针指向前一个指针：p->next = p_pre；
（3）当前指针赋值给前一个指针存储变量：p_pre = p；
（4）当前指针指向下一个指针： p = p_next；

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if (!pHead)
            return NULL;
        ListNode* p = pHead;
        ListNode* p_pre = NULL;
        ListNode* p_next = p->next;
        while (p->next) {
            p_next = p->next;
            p->next = p_pre;
            p_pre = p;
            p = p_next;
        }
        p->next = p_pre;        //处理最后结点
        pHead = p;                //将尾结点设置为头结点
        p = NULL;
        p_pre = NULL;
        p_next = NULL;
        free(p);
        free(p_pre);
        free(p_next);
        return pHead;
    }
};