又来更新剑指offer上的题目思路啦。
11、【二进制中1的个数】
题目：输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
eg：NumberOf1(1)=1 NumberOf1(2)=0 NumberOf1(3)=2 NumberOf1(4)=1 NumberOf1(5)=2 NumberOf1(6)=2 NumberOf1(7)=3
思路：每次都将数字n的最后一位1反转成0，不断反转到这个数字变成0，然后我们统计反转了多少次，这样不就可以成功得到这个数字有多少位了吗？
难点：如何反转一个数字的最后一位1，解决方案如下：
n = n & (n - 1);
代码：
int NumberOf1(int n) {
int number = 0;
while (n != 0)
{
n = n & (n - 1);
++number;
}
return number;
}
思路2：可不可以尝试不去改变这个数字呢？答案也可以的。假设是int类型，如果我循环32次，判断每个位是否为1，这样不也可以得到这个数字有多少位为1吗？诚然，这样也是存在着缺点的。
缺点：比思路1的时间复杂度略高，不过也是常数级别的，因为数字的位数是有限制的，两者可能系数上存在着差别吧！~~~还有一个缺点，就是这样的代码移植性较差~~
存在坑：
(temp & n) != 0
这里的括号不能去掉，因为&的优先级比 != 低。。。。
代码：
int NumberOf1(int n) {
int number = 0;
int temp = 1;
for (int i = 0; i < 32; ++i)
{
if ((temp & n) != 0)
{
++number;
}
temp = temp<<1;
}
return number;
}
12、【数值的整数次方】
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
例子：2^10
思路1：2*2*2*2*2*2*2*2*2*2，循环N次即可。时间复杂度O(n)没啥好说的，跳过。
思路2: 分治想法，假设是求a^n
如果n为偶数，那么转化成求x=a^(n/2)，然后返回x*x即可。
如果n为奇数，那么转化成求x=a^(n-1/2)，然后返回x*x*a即可。
时间复杂度是O(lgn)。。。怎么证明？
应用算法导论中的主方法即可。
这里，有T(n) = T(n/2) + 1，即 b = 2, a = 1，f(n)=1。因此满足条件2，因此时间复杂度为O(nlogb(a))=O(nlog2(1)*lgn)=O(1*lgn)=O(lgn)。
哈哈，是不是瞬间感觉写难了。。。。
13、【调整数组顺序使奇数位于偶数前面】
题目：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
思路：两个数组，一个按顺序保存奇数，另一个按顺序保存偶数。。。时间复杂度O(N)，空间复杂度O(N)。
思路2：创建一个数组，循环2次，第一次只扫描奇数，丢进数组中。第二次只扫描偶数，丢进数组。。十分简单。。。
思路3：类似冒泡算法，前偶后奇数就交换。
void reOrderArray(vector<int> &arr) {//双指针 int n = arr.size(); for(int i = 0; i < n; ++i) { for(int j = 0; j < n-i-1; ++j) { if(arr[j]%2 == 0 && arr[j+1]%2 == 1) swap(arr[j],arr[j+1]); } } }
思路4：两个指针咯，一个指针1从头到尾，另外一个指针2从尾到头，如果指针1发现偶数，那么停下来，如果指针2发现奇数，那么也停下来。再交换两个指针指向的数就Ok了。
问题：这样是真的可以吗？答案是不可以的哦~哈哈，因为这样违反了题目要求——要求奇数和偶数顺序不能改变。。。嗯，是的，如果是让顺序可以随意的话，那么这就是很nice的解。
14、【链表中倒数第k个结点】
题目：输入一个链表，输出该链表中倒数第k个结点。
思路1：遍历得到链表长度n，然后再遍历一次，给返回第n-k+1个元素。这里遍历了两次，时间复杂度为0(n)，空间复杂度为O(1)。
思路2：思路1是否存在优化的地方呢？是存在的，我们可以考虑考虑能不能不遍历两次，这时候我们想能不能用空间换时间。
好比，将链表转化成数组保存下来，那么我们第二次遍历链表操作可以换成获取数组中的n-k+1个元素操作了，只需要遍历一次链表就可以了。但是这种方法的空间复杂度为O(N)。
思路3：两个指针，也就是传说中的快慢指针。一个指针先走k步，然后慢指针才开始跑。快指针到头了，那么落后了k步的慢指针不就是倒数第k个元素了吗？
代码:
ListNode* FindKthToTail(ListNode* pListHead, unsigned int k)
{
if(NULL == pListHead) return NULL;
ListNode* pfront = pListHead;
ListNode* pend = pListHead;
for (int i = 0; i < k; i++)
{
if(pfront != NULL)
{
pfront = pfront->next;
}
else
{
return NULL;//超出了
}
}
for(;pfront != NULL;pfront = pfront->next)
{
pend = pend->next;
}
return pend;
}
15、【反转链表】
输入一个链表，反转链表后，输出链表的所有元素。
A->B->C->D->E
A->B->C->D<-E (D->NULL)
A->B->C<-D<-E (C->NULL)
A->B<-C<-D<-E (B->NULL)
A<-B<-C<-D<-E (A->NULL)
代码
ListNode* ReverseList(ListNode* pHead)
{
if(pHead == NULL||pHead->next == NULL) return pHead;//得到链表尾部
ListNode* tail = ReverseList(pHead->next);
pHead->next->next = pHead;
pHead->next = NULL;
return tail;
}
16、【合并两个排序的链表】
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
额，这题啥也不用说了吧，，，不就是归并排序的合并过程么。。。。直接贴代码吧。。。
ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
{
ListNode* res = NULL;
ListNode* cur = NULL;
ListNode* add = NULL;
if(pHead1 == NULL) return pHead2;
if(pHead2 == NULL) return pHead1;
while(pHead1 != NULL &&pHead2 != NULL)//两个迭代器
{
add = pHead1->val >= pHead2->val ?pHead2:pHead1;
if(res == NULL) res = cur = add;////////////第一次才执行 在于选择一条链出来
else
{
cur->next = add;
cur = cur->next;
}
if(add == pHead1) pHead1=pHead1->next;
else pHead2 = pHead2->next;
}
if(pHead1 != NULL) cur->next = pHead1;
if(pHead2 != NULL) cur->next = pHead2;
return res;
}
17、【树的子结构】
题目：输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
其实这里主要是靠对问题的拆分能力。
子函数CompTree：判断两棵树是否相等。
判断是否为子树：假设当前节点为根，那么是否为子结构？
代码：
class Solution {
private:
bool CompTree(TreeNode* pRoot1, TreeNode* pRoot2)//判断2是否为1的子树。。。。
{
if(pRoot2 == NULL) return true;
if(pRoot1 == NULL) return false;
if(pRoot1->val == pRoot2->val)
return CompTree(pRoot1->left,pRoot2->left)&&CompTree(pRoot1->right,pRoot2->right);
return false;
}
public:
bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
{
if(pRoot1 == NULL ||pRoot2 == NULL ) return false;
return CompTree(pRoot1,pRoot2) || HasSubtree(pRoot1->left,pRoot2) || HasSubtree(pRoot1->right, pRoot2);
}
};
18、