位1的个数
编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
示例 :
输入: 11
输出: 3
解释: 整数 11 的二进制表示为 00000000000000000000000000001011
示例 2:
输入: 128
输出: 1
解释: 整数 128 的二进制表示为 00000000000000000000000010000000
思路：
将n的每一位与1进行与运算，为真就说明n的最后一位是1，n右移一位，左边补0，直到n全部移除为0
c++代码
class Solution {
public:
int hammingWeight(uint32_t n) {
int count = 0;
while ( n )
{
if( n & 1 ){
++count;
}
n >>= 1; //右移一位
}
return count;
}
};
汉明距离
两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。
给出两个整数 x 和 y，计算它们之间的汉明距离。
注意：
0 ≤ x, y < 231.
示例:
输入: x = 1, y = 4
输出: 2
解释:
1 (0 0 0 1)
4 (0 1 0 0)
↑ ↑
上面的箭头指出了对应二进制位不同的位置。
思路：
按位异或，不同的位置就变成了1，就看有多少个1，跟上题就一样了
c++代码
class Solution {
public:
int hammingDistance(int x, int y) {
int count=0;
int temp=x^y;//按位异或
while(temp)
{
if(temp&1)
count++;
temp>>=1;//右移一位
}
return count;
}
};
颠倒二进制位
颠倒给定的 32 位无符号整数的二进制位。
示例:
输入: 43261596
输出: 964176192
解释: 43261596 的二进制表示形式为 00000010100101000001111010011100 ，
返回 964176192，其二进制表示形式为 00111001011110000010100101000000 。
进阶:
如果多次调用这个函数，你将如何优化你的算法？
c++代码
class Solution {
public:
uint32_t reverseBits(uint32_t n) {
uint32_t m=0;
for(int i=0;i<32;i++)
{
m<<=1;//m左移一位
m=m|(n&1);//赋给m
n>>=1;//n右移一位
}
return m;
}
};
帕斯卡三角形
给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 5
输出:
[
[1],
[1,1],
[1,2,1],
[1,3,3,1],
[1,4,6,4,1]
]
c++代码
class Solution {
public:
vector<vector<int>> generate(int numRows) {
vector<int> row;
vector<vector<int>> nums(numRows,row);
for(int i=0;i<numRows;i++)
{
nums[i].push_back(1);
for(int j=1;j<i;j++)
{
nums[i].push_back(nums[i-1][j]+nums[i-1][j-1]);
}
if(i>0)
nums[i].push_back(1);
}
return nums;
}
};
总是报错reference binding to null pointer of type ‘value_type’
查了查应该是对于vector构建出来的二维数组没有进行空间的申请,比如有些返回类型为vector<vector<>>类型的函数，对于这个返回值vector表示的二维数组要先申请大小，否则使用下标访问就会报这类错误。
有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: “()”
输出: true
示例 2:
输入: “()[]{}”
输出: true
示例 3:
输入: “(]”
输出: false
示例 4:
输入: “([)]”
输出: false
示例 5:
输入: “{[]}”
输出: true
c++代码
class Solution {
public:
bool isValid(string s) {
stack<char> arr;
for(int i=0;i<s.length();i++)
{
if(arr.empty())
arr.push(s[i]);
//能凑成一对就出栈
else if(arr.top()=='('&&s[i]==')'||arr.top()=='['&&s[i]==']'||arr.top()=='{'&&s[i]=='}')
arr.pop();
else
arr.push(s[i]);
}
if(arr.empty())
return true;
else
return false;
}
};
缺失数字
给定一个包含 0, 1, 2, …, n 中 n 个数的序列，找出 0 … n 中没有出现在序列中的那个数。
示例 1:
输入: [3,0,1]
输出: 2
示例 2:
输入: [9,6,4,2,3,5,7,0,1]
输出: 8
说明:
你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现?
c++代码
方法一：
新建一个0-n的数组flag，下标代表n个数，值代表是否存在这个数，开始都设为0，表示不存在这个数，遍历一遍nums，将所有遇到的都设为1.最后为0的就是没有出现的。但是这个空间复杂度O(n)
class Solution {
public:
int missingNumber(vector<int>& nums) {
if(nums.empty())
return 0;
int n=nums.size();
vector<int> flag;
for(int i=0;i<=n;i++)
{
flag.push_back(0);
}
for(int i=0;i<n;i++)
{
flag[nums[i]]=1;
}
for(int j=0;j<=n;j++)
{
if(flag[j]==0)
return j;
}
}
};
方法二：
不缺失数字时候的加和可以计算，缺失数字之后的加和遍历一遍也可以计算出来，二者相减不就是缺失的数字了
class Solution {
public:
int missingNumber(vector<int>& nums) {
if(nums.empty())
return 0;
int sum=0,sum2=0;
int n=nums.size();
//缺失数字的加和
for(int i=0;i<n;i++)
sum=sum+nums[i];
//未缺失数字加和
for(int i=0;i<n+1;i++)
{
sum2=sum2+i;
}
return sum2-sum;
}
};