百度codetop-4

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;
            }
		}
    }
};