本文解析了包括Hamming距离、合并二叉树、计数位数等八道经典编程题目，提供了Python及C++的解决方案，并介绍了相关知识点如二进制运算、二叉树操作、动态规划等。
1.Hamming Distance
class Solution(object):
def hammingDistance(self, x, y):
"""
:type x: int
:type y: int
:rtype: int
"""
return bin(x^y).count('1')
python
bin() 返回一个整数 int 或者长整数 long int 的二进制表示，返回字符串。
str.count(sub, start= 0,end=len(string)) 该方法返回子字符串在字符串中出现的次数。
sub – 搜索的子字符串
start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
2.Merge Two Binary Trees
class Solution(object):
def mergeTrees(self, t1, t2):
if t1 and t2:
root = TreeNode(t1.val + t2.val)
root.left = self.mergeTrees(t1.left, t2.left)
root.right = self.mergeTrees(t1.right, t2.right)
return root
else:
return t1 or t2
and x and y 布尔”与” - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔”或” - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False
python 中的and从左到右计算表达式，若所有值均为真，则返回最后一个值，若存在假，返回第一个假值。
or也是从左到有计算表达式，返回第一个为真的值。
3.Counting Bits
找规律，参见博客http://www.cnblogs.com/grandyang/p/5294255.html
class Solution {
public:
vector<int> countBits(int num) {
vector<int> ret(num+1, 0);
for (int i = 1; i <= num; ++i)
ret[i] = ret[i&(i-1)] + 1;
return ret;
}
};
C++ vector:
vector<int> a ; //声明一个int型向量a
vector<int> a(10) ; //声明一个初始大小为10的向量
vector<int> a(10, 1) ; //声明一个初始大小为10且初始值
4.Island Perimeter
思路参见博客http://www.cnblogs.com/grandyang/p/6096138.html
class Solution {
public:
int islandPerimeter(vector<vector<int>>& grid) {
if (grid.empty() || grid[0].empty()) return 0;
int res = 0, m = grid.size(), n = grid[0].size();
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (grid[i][j] == 0) continue;
res += 4;
if (i > 0 && grid[i - 1][j] == 1) res -= 2;
if (j > 0 && grid[i][j - 1] == 1) res -= 2;
}
}
return res;
}
};
要点：vector.empty()
5.Queue Reconstruction by Height
见博客http://www.cnblogs.com/grandyang/p/5928417.html
def reconstructQueue(self, people):
"""
:type people: List[List[int]]
:rtype: List[List[int]]
"""
ans = []
for i in sorted(people, key=lambda x: (-x[0], x[1])):
ans.insert(i[1], i)
return ans
利用list.sort()参数key指定元素排序
>>> a.append(('a',1))
>>> a.append(('b',20))
>>>a.append(('c',-200))
>>> a.sort(key=lambda d:d[1],reverse=True)
>>> a
[('b', 20), ('a', 1), ('c', -200)]
list.insert(index, obj)：
index – 对象 obj 需要插入的索引位置。
obj – 要插入列表中的对象。
C++解法：
class Solution {
public:
vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people) {
sort(people.begin(), people.end(), [](const pair<int, int>& a, const pair<int, int>& b) {
return a.first > b.first || (a.first == b.first && a.second < b.second);});
vector<pair<int, int>> res;
for (auto a : people) {
res.insert(res.begin() + a.second, a);
}
return res;
}
};
C++ pair的用法:
http://blog.youkuaiyun.com/oceanlight/article/details/7890537
C++ sort:
sort(begin,end,compare)
bool compare(int a,int b)
{
return a<b; //升序排列，如果改为return a>b，则为降序
}
C++ auto:
自 C++ 11 以来，auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。
auto f=3.14; //double
auto s("hello"); //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型
匿名函数:
http://www.cnblogs.com/lidabo/p/3908663.html
C++ for循环范围迭代：
int my_array[5] = {1, 2, 3, 4, 5};
// 每个数组元素乘于 2
for (int &x : my_array)
{
x *= 2;
cout << x << endl;
}
// auto 类型也是 C++11 新标准中的，用来自动获取变量的类型
for (auto &x : my_array) {
x *= 2;
cout << x << endl;
}
Ｃ＋＋ vector.insert():
iterator insert( iterator loc, const TYPE &val );
void insert( iterator loc, size_type num, const TYPE &val );
void insert( iterator loc, input_iterator start, input_iterator end );
insert() 函数有以下三种用法:
在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器,
在指定位置loc前插入num个值为val的元素
在指定位置loc前插入区间[start, end)的所有元素 .
举例:
//创建一个vector,置入字母表的前十个字符
vector <char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
//插入四个C到vector中
vector <char>::iterator theIterator = alphaVector.begin();
alphaVector.insert( theIterator, 4, 'C' );
//显示vector的内容
for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ )
cout < < *theIterator;
这段代码将显示:
CCCCABCDEFGHIJ
6.Palindromic Substrings
int countSubstrings(string s) {
int res = 0, n = s.length();
for(int i = 0; i < n; i++){
for(int j = 0; i-j >= 0 && i+j < n && s[i-j] == s[i+j]; j++)res++;
for(int j = 0; i-1-j >= 0 && i+j < n && s[i-1-j] == s[i+j]; j++)res++;
}
return res;
}
见博客http://blog.youkuaiyun.com/huanghanqian/article/details/76577138
1)动态规划
2)遍历回文串中心
7.Single Number
1)xor(异或)满足交换律
2)任何数跟0异或等于它本身
class Solution {
public:
int singleNumber(vector<int>& nums) {
int ans = 0;
for(int i = 0; i < nums.size(); i++) {
ans ^= nums[i];
}
return ans;
}
};
8.Maximum Depth of Binary Tree
见博客http://www.cnblogs.com/grandyang/p/4051348.html
class Solution {
public:
int maxDepth(TreeNode* root) {
if (!root) return 0;
return 1 + max(maxDepth(root->left), maxDepth(root->right));
}
};
C++ max()
1)用递归进行深度优先搜索（DFS）
2)层序遍历二叉树（利用队列）
python or/and:
python 中的and从左到右计算表达式，若所有值均为真，则返回最后一个值，
若存在假，返回第一个假值。
or也是从左到有计算表达式，返回第一个为真的值。
>>'a'and'b'
'b'
>>''and'b'
''
>>'a'or'b'
'a'
>>''or'b'
'b'
9. Invert Binary Tree
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if (root) {
swap(root->left, root->right);
invertTree(root->right);
invertTree(root->left);
}
return root;
}
};
见博客：http://www.cnblogs.com/grandyang/p/4572877.html
1)递归
2)队列
idea:跟层序遍历相关的都可以用队列搞定
10.Find All Numbers Disappeared in an Array
见博客http://www.cnblogs.com/grandyang/p/6222149.html
class Solution {
public:
vector<int> findDisappearedNumbers(vector<int>& nums) {
vector<int> res;
for (int i = 0; i < nums.size(); ++i) {
int idx = abs(nums[i]) - 1;
nums[idx] = (nums[idx] > 0) ? -nums[idx] : nums[idx];
}
for (int i = 0; i < nums.size(); ++i) {
if (nums[i] > 0) {
res.push_back(i + 1);
}
}
return res;
}
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
