[剑指offer]合集

发现每一个建一个博客真的有些烦，索性弄一个合集

->矩形覆盖

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

找规律：n=1    1;  n=2  2;  n=3   3;  n=4  5; n=5  8......f(n)=f(n-1)+f(n-2)

class Solution {
public:
    int rectCover(int number) {
		if(number<=2)
            return number;
        int a = 2;
        int b = 1;
        while(number-->2)
            {
            a = a+b;
            b = a-b;
        }
        return a;
    }
};

->二进制中1的个数

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

class Solution {
public:
     int  NumberOf1(int n) {
         int tmp=1;
         int total = 0;
         for(int i=0; i<32; i++)
             {
             total += tmp&(n>>i);
         }
         return total;
     }
};

最开始写成total += n&(tmp<<i) 当n=10的时候，total=10.出现这个问题的原因是这样的：total=10对应二进制位1010, tmp一直在左移，1010&1000 = 1000变成十进制为8

->翻转链表

输入一个链表，反转链表后，输出链表的所有元素。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
		if(pHead==NULL)
            return pHead;
        ListNode tmp_head(0);
        tmp_head.next = pHead;
        
        vector<int> data;
        while(pHead!=NULL)
            {
            data.insert(data.begin(),pHead->val);
            pHead=pHead->next;
        }
        pHead=tmp_head.next;
        for(int i=0; i<data.size(); i++)
            {
            pHead->val = data[i];
            pHead = pHead->next;
        }
        return tmp_head.next;
    }
};

->变态跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

一如既往的找规律：

台阶          1       2       3        4

多少种       1      2       4        8

f(n)=2^(n-1)

[cpp]  view plain  copy

1. class Solution {  
2. public:  
3.     int jumpFloorII(int number) {  
4.         return (pow(2,number-1));  
5.     }  
6. };  

->跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

这个问题其实就是找规律：

台阶：         1        2       3       4        5 

多少种：     1        2       3       5        8

可以看到f(n)=f(n-1)+f(n-2)和之前做的那个菲波那切数列很像，是一类问题

[cpp]  view plain  copy

1. class Solution {  
2. public:  
3.     int jumpFloor(int number) {  
4.         if((number==1)||(number==2))  
5.             return number;  
6.           
7.         int a=1;  
8.         int b=2;  
9.         while(number-->2)  
10.             {  
11.             b=a+b;  
12.             a=b-a;  
13.         }  
14.         return b;  
15.     }  
16. };  

->菲波那切数列

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。

n<=39

牛客网上面如果用递归就会显示超时，后来改成非递归的方式

[cpp]  view plain  copy

1. class Solution {  
2. public:  
3.     int Fibonacci(int n) {  
4.         if(n==0)  
5.             return 0;  
6.         if(n<=2)  
7.             return 1;  
8.           
9.         int a=1;  
10.         int b=1;  
11.         while(n-->2)  
12.             {  
13.             a += b;  
14.             b = a-b;  
15.         }  
16.         return a;  
17.     }  
18. };  

->旋转数字的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

[cpp]  view plain  copy

1. class Solution {  
2. public:  
3.     int minNumberInRotateArray(vector<int> rotateArray) {  
4.         if(rotateArray.size()==0)  
5.             return 0;  
6.           
7.         sort(rotateArray.begin(),rotateArray.end());  
8.             return rotateArray[0];  
9.     }  
10. };  

->从尾到头打印链表

输入一个链表，从尾到头打印链表每个节点的值。

[cpp]  view plain  copy

1. /** 
2. *  struct ListNode { 
3. *        int val; 
4. *        struct ListNode *next; 
5. *        ListNode(int x) : 
6. *              val(x), next(NULL) { 
7. *        } 
8. *  }; 
9. */  
10. class Solution {  
11. public:  
12.     vector<int> printListFromTailToHead(ListNode* head) {  
13.         vector<int> data;  
14.         while(head!=NULL)  
15.             {  
16.             data.insert(data.begin(),head->val);  
17.             head=head->next;  
18.         }  
19.         return data;  
20.     }  
21. };  
22. 
    

->替换空格

请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

[cpp]  view plain  copy

1. class Solution {  
2. public:  
3.     void replaceSpace(char *str,int length) {  
4.         vector<char> result;  
5.         for(int i=0; i<length; i++)  
6.         {  
7.             if(str[i]!=' ')  
8.                 result.push_back(str[i]);  
9.             else  
10.                 {  
11.                 result.push_back('%');  
12.                 result.push_back('2');  
13.                 result.push_back('0');  
14.             }  
15.         }  
16.         for(int i=0; i<result.size(); i++)  
17.             {  
18.             *str++=result[i];  
19.         }  
20.     }  
21. };