LeetCode开始刷题

191 Number of 1 bits

被AC的代码：

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int cnt=0;
        int tmp=1;
        while(n){
            if((n&tmp)==1)
              ++cnt;
            n=n>>1;
        }
        return cnt;        
    }
};

当中出现的问题是将右移运算（>>)写成了大于号（>），后来改正了。假如形参中n不是无符号数，而是一个有符号的负数，会造成死循环。

另一种是将n与1求与运算，判断n的最低位是否为1。接着把1左移1位得到2，再和n做与运算，就能判断n的次低位是否为1，。。。这样反复左移，每次都能判断n的其中一位是否为1。这种思路是正确的，但是判断时应该判断n&tmp的结果是否为0，而不应该判断结果是否为1（10&10的结果是10，不会等于1，cnt不会加1）。

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int cnt=0,tmp=1;
        while(tmp){
            if((n&tmp))     //不能写成if((n&tmp)==1)
              ++cnt;
            tmp=tmp<<1;
        }
        return cnt;
        
    }
};

但是这种以上两种方法思路是相似的，第一种思路的循环次数为n中1的位数。第二种思路的缺点就是循环的次数等于整数n的二进制位数。在Leetcode上测试多个cases时，速度非常慢。

第三种思路：把一个整数减去1，再和原整数做与运算，会把该整数最右边的一个1变为0。那么一个整数的二进制表示中有多少个1，就可以进行多少次这样的运算。

但是还是写出错误的代码：

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int cnt=0;
        while(n){
            if(n&(n-1))
                ++cnt;
            n = n&(n-1);
        }
        return cnt;
        
    }
};

应该是：

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int cnt=0;
        while(n){
            ++cnt;
            n = n&(n-1);
        }
        return cnt;
        
    }
};

190题Reverse Bits

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        int mvTimes = 32;
        uint32_t sum=0;
        int flag=1;
        uint32_t tmp=n;
        while(mvTimes)
        {
            --mvTimes;
            sum = sum<<1;
            if(tmp&flag)
               sum = sum+1;
            tmp = tmp>>1;
        }
        return sum;
    }
};

LeetCode7: Reverse integer

class Solution {
public:
    int reverse(int x) {
        bool Ngflag=false;
        long long sum=0;
        const int min = 0x80000000; //2147483647
        const int max = 0x7fffffff;  //-2147483648
        if (x<0)
        {
            Ngflag = true;
            //x = 0-x;
        }
        
        
        while(x)
        {           
           sum = sum*10 + x%10;
           x = x/10;
           if(sum>max && Ngflag==false) //直接写成 if(sum>0x7fffffff&& Ngflag==false)  不行，为什么
              return 0;
           if(sum<min && Ngflag==true)  //直接写成 if(sum<0x80000000&& Ngflag==false)不行，为什么
              return 0;  
            
        }
        return sum;
    }
};

//if(sum<min && Ngflag==true)  //直接写成 if(sum<0x80000000&& Ngflag==false)不行，为什么?

因为sum是long long 类型的，字节数比0x80000000多，假如直接写0x80000000，sum和0x80000000进行比较时，会将0x80000000当成是long long 类型的正数，导致x是负数时输出结果为0。

而直接写成sum<min 是可以的，因为min是int有符号类型的，sum和min比较时，会知道min的值是一个负数。即使有类型提升，min的值也不会变。

可以看看这篇文章：

http://www.cnblogs.com/airwindow/p/4192732.html

通常取模运算也叫取余运算，他们都遵循处罚法则，返回结果都是余数；但是仔细看是不一样的，详细请看实例： rem(3,2)=1 rem(-3,-2)=-1 rem(3,-2)=1 rem(-3,2)=-1 mod(3,2)=1 mod(-3,-2)=-1 mod(3,-2)=-1 mod(-3,2)=1 由此可以看出，rem和mod是有符号区别的！当除数与被除数的符号相同时，rem和mod的结果是完全相同的；当除数与被除数的符号不相同时，结果不同。具体说，rem结果的符号与被除数相同；mod结果的符号与除数相同。       建议你到百度学习！

118 Pascal's Triangle  （注意下标就可以了）
class Solution {
public:
    vector<vector<int> > generate(int numRows) {
        vector<vector<int> > ret;
        vector<int> ret1={1};
        vector<int> ret2={1,1};
        if(numRows<=0)
           return ret;
        if(numRows==1)
        {
            ret.push_back(ret1);
            return ret;
        }
        if(numRows==2)
        {
            ret.push_back(ret1);
            ret.push_back(ret2);
            return ret;
        }
        
        ret.push_back(ret1);
        ret.push_back(ret2);
       
        for (int i=2; i<=numRows-1; ++i)
        { 
            vector<int> tmp(i+1,1);
            for(int j=1; j<i; ++j)
            {
                //tmp.at(j) = ret[i-1][j-1] + ret[i-1][j];
                tmp.at(j) = ret.at(i-1).at(j-1) + ret.at(i-1).at(j) ;//两种方式都可以
            }
            ret.push_back(tmp);
        }
        return ret;
        
    }
};