1、从前序与中序遍历序列构造二叉树
根据一棵树的前序遍历与中序遍历构造二叉树。
class Solution {
public:
unordered_map<int, int> map;
int preindex;
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int n = inorder.size();
for(int i = 0; i < n; i++){
map[inorder[i]] = i;
}
preindex = 0;
return helper(preorder, 0, n - 1);
}
TreeNode* helper(vector<int> &preorder, int l, int r){
if(l > r) return nullptr;
int val = preorder[preindex];
preindex++;
TreeNode* root = new TreeNode(val);
int index = map[val];
root->left = helper(preorder, l, index - 1);
root->right = helper(preorder, index + 1, r);
return root;
}
};
2、买卖股票的最佳时机
给定一个数组 prices ,它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票,并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润,返回 0 。
class Solution {
public:
int maxProfit(vector<int>& prices) {
int res = 0;
if(prices.size() == 0) return res;
int maxvalue = 0;
int minvalue = prices[0];
for(int i = 0; i < prices.size(); i++){
minvalue = min(minvalue, prices[i]);
maxvalue = max(maxvalue, prices[i] - minvalue);
}
return maxvalue;
}
};
3、翻转字符串里的单词
给你一个字符串 s ,逐个翻转字符串中的所有 单词 。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
请你返回一个翻转 s 中单词顺序并用单个空格相连的字符串。
class Solution {
public:
string reverseWords(string s) {
reverse(s.begin(), s.end());
int n = s.size();
int index = 0;
for(int start = 0; start < n; start++){
if(s[start] != ' '){
if(index != 0) index++;
int end = start;
while(end < n && s[end] != ' ') s[idx++] = s[end++];
reverse(s.begin() + index - (end - start), s.begin() + index);
start = end;
}
}
s.erase(s.begin() + index, s.end());
return s;
}
};
4、回文数
给你一个整数 x ,如果 x 是一个回文整数,返回 true ;否则,返回 false 。
回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。例如,121 是回文,而 123 不是。
class Solution {
public:
bool isPalindrome(int x) {
if(x < 0 || (x % 10 == 0 && x != 0))
return false;
int reverse = 0;
while(x > reverse){
reverse = reverse * 10 + x % 10;
x = x / 10;
}
if(x == reverse || x == reverse / 10)
return true;
else return false;
}
};
5、两数之和
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
vector<int> res;
unordered_map<int, int> map;
for(int i = 0; i < nums.size(); i++){
int tmp = target - nums[i];
if(map.find(tmp) != map.end()){
res.push_back(map[tmp]);
res.push_back(i);
break;
}
map[nums[i]] = i;
}
return res;
}
};
6、不同路径
一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish” )。
问总共有多少条不同的路径?
class Solution {
public:
int uniquePaths(int m, int n) {
vector<vector<int>> dp(m, vector<int>(n));
for(int i = 0; i < m; i++){
dp[i][0] = 1;
}
for(int i = 0; i < n; i++){
dp[0][i] = 1;
}
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
};
7、两个数组的交集
给定两个数组,编写一个函数来计算它们的交集。
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
sort(nums1.begin(), nums1.end());
sort(nums2.begin(), nums2.end());
int index1 = 0, index2 = 0;
int n1 = nums1.size(), n2 = nums2.size();
vector<int> res;
while(index1 < n1 && index2 < n2){
int num1 = nums1[index1], num2 = nums2[index2];
if(num1 == num2){
if(res.empty() || num1 != res.back())
res.push_back(num1);
index1++;
index2++;
}
else if(num1 < num2)
index1++;
else
index2++;
}
return res;
}
};
8、x的平方根
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根,其中 x 是非负整数。
由于返回类型是整数,结果只保留整数的部分,小数部分将被舍去。
class Solution {
public:
int mySqrt(int x) {
int l = 0, r = x, res = 0;
while(l <= r){
int mid = (l + r) / 2;
if((long long)mid * mid <= x){
res = mid;
l = mid + 1;
}
else r = mid - 1;
}
return res;
}
};
9、数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字。
class Solution {
public:
int majorityElement(vector<int>& nums) {
int vote = 0, res = 0;
for(auto num : nums){
if(vote == 0) res = num;
if(res == num) vote++;
else vote--;
}
return res;
}
};
10、设计哈希映射
不使用任何内建的哈希表库设计一个哈希映射(HashMap)。
实现 MyHashMap 类:
MyHashMap() 用空映射初始化对象
void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中,则更新其对应的值 value 。
int get(int key) 返回特定的 key 所映射的 value ;如果映射中不包含 key 的映射,返回 -1 。
void remove(key) 如果映射中存在 key 的映射,则移除 key 和它所对应的 value
class MyHashMap {
private:
vector<list<pair<int, int>>> data;
static const int base = 769;
static int hash(int key) {
return key % base;
}
public:
MyHashMap(): data(base) {}
void put(int key, int value) {
int h = hash(key);
for(auto it = data[h].begin(); it != data[h].end(); it++){
if((*it).first == key){
(*it).second = value;
return;
}
}
data[h].push_back(make_pair(key, value));
}
int get(int key) {
int h = hash(key);
for(auto it = data[h].begin(); it != data[h].end(); it++){
if((*it).first == key)
return (*it).second;
}
return -1;
}
void remove(int key) {
int h = hash(key);
for(auto it = data[h].begin(); it != data[h].end(); it++){
if((*it).first == key){
data[h].erase(it);
return;
}
}
}
};