leecode[一]
文章目录
- 938 二叉搜索树的范围和
- 881. 救生艇
- 844. 比较含退格的字符串
- 692. 前K个高频单词
- 268. 缺失数字
938 二叉搜索树的范围和
给定二叉搜索树的根结点 root，返回 L 和 R（含）之间的所有结点的值的和。
二叉搜索树保证具有唯一的值。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int rangeSumBST(TreeNode* root, int L, int R) {
vector<int> value;
InOrder(root,&value);
int sum=0,left=0,right=6;
bool begin=false;
for(int i=0;i<value.size();i++)
{
if(value[i]==L && begin==false){
left=i;
begin=true;
}
if(value[i]==R){
right=i;
}
}
for(int i=left;i<right+1;i++){
sum=sum+value[i];
}
return sum;
}
void InOrder(TreeNode* root,vector<int> * value){
if(root!=NULL)
{
InOrder(root->left,value);
value->push_back(root->val);
InOrder(root->right,value);
}
}
};
static const auto kSpeedUp = []() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
return nullptr;
}();
二叉搜索树：
左节点小于根节点，右节点大于根节点
注意点：
（1）vector的作为函数参数需要传指针，传值是无效的。
（2）动态数组vector访问可以直接和数组一样vector [1],添加元素可以使用push_back。
（3）对于指针对象的成员函数或成员变量，应该使用->而不能使用.
而对于&或者对象本身，需要使用.而不应该使用->
InOrder(root->right,value); //正确
InOrder(root.right,value); //错误
（4）最后一段增加代码执行速度用的。
（5）NULL空指针，不是null
//完全迭代遍历
class Solution {
public:
int rangeSumBST(TreeNode* root, int L, int R) {
if (root==NULL){
return 0;
}
if(root->val>=L && root->val<=R)
return root->val + rangeSumBST( root->left, L, R) + rangeSumBST( root->right, L, R);
else
return rangeSumBST( root->left, L, R) + rangeSumBST( root->right, L, R);
}
};
//根据二叉搜索树来进行迭代遍历
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int rangeSumBST(TreeNode* root, int L, int R) {
if (root==NULL){
return 0;
}
if(root->val>=L && root->val<=R)
return root->val + rangeSumBST( root->left, L, R) + rangeSumBST( root->right, L, R);
else if(root->val<L)
return rangeSumBST( root->right, L, R);
else
return rangeSumBST( root->left, L, R);
}
};
881. 救生艇
第 i 个人的体重为 people[i]，每艘船可以承载的最大重量为 limit。
每艘船最多可同时载两人，但条件是这些人的重量之和最多为 limit。
返回载到每一个人所需的最小船数。(保证每个人都能被船载)。
class Solution {
public:
int numRescueBoats(vector<int>& people, int limit) {
int num=0;
sort(people.begin(),people.end());
for(int i=0,j=people.size()-1;j>i;j--){
if(people[j]+people[i]<=limit){
num++;
if(i+2==j){ //中间只剩下一个人
num++;
break;
}
i++;
}
else{
num++;
if(i+1==j){ //中间没有人，但是两个人的重量加起来也超过最大限制。
num++;
break;
}
}
}
return num;
}
};
static int speed_up = []() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
return 0;
}();
注意点：
（1）vector数组大小，vector[vector.size()-1]
（2）void sort(RanIt first, RanIt last, cmp);前两个参数为迭代器指针，分别指向容器的首尾，第三个参数为比较方法，默认是升序排列。必须的头文件#include < algorithm>和using namespace std; 可以自定义cmp:
bool cmp(int x, int y) {
return x > y;
}
844. 比较含退格的字符串
给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。
class Solution {
public:
bool backspaceCompare(string S, string T)
{
vector<char>v1,v2;
for(char element:S)//处理S中的所有字符，结果存储在v1中
{
if(element!='#')
v1.push_back(element);
else
{
if(!v1.empty())
v1.pop_back();
}
}
for(char element:T)//处理T中的所有字符，结果存储在v2中
{
if(element!='#')
v2.push_back(element);
else
{
if(!v2.empty())
v2.pop_back();
}
}
if(v1!=v2)//判断得到的v1和v2是否相同
return false;
return true;
}
};
// 还没想清楚为什么错
// class Solution {
// public:
// bool backspaceCompare(string S, string T) {
// string s,t;
// for(int i=0;i
// if(S[i]!='#')
// {
// s=s+S[i];
// }else{
// if(s.length()!=0){
// s.pop_back();
// }
// }
// }
// for(int i=0;i
// if(T[i]!='#')
// {
// t=t+T[i];
// }else{
// if(t.length()!=0){
// t.pop_back();
// }
// }
// }
// if(s.length()!=t.length()){
// return false;
// }else{
// for(int i=0;i
// {
// if(s[i]!=t[i]){
// return false;
// }
// }
// return true;
// }
// }
// };
692. 前K个高频单词
class Solution {
public:
typedef pair<string, int> PAIR;
struct CmpByValue {
bool operator()(const PAIR& lhs, const PAIR& rhs) {
if(lhs.second != rhs.second)
return lhs.second > rhs.second;
else{
return lhs.first < rhs.first;
}
}
};
struct CmpByValue1 {
bool operator()(const PAIR& lhs, const PAIR& rhs) {
return lhs.first.compare(rhs.first)>0;
}
};
vector<string> topKFrequent(vector<string>& words, int k) {
unordered_map<string,int> word_map;
unordered_map<string,int> result_map;
for(int i=0;i<words.size();i++){
// map::iterator iter;
// iter = word_map.find(words[i]);
// if(iter!=word_map.end()){
word_map[words[i]]++;
// }else{
// word_map.insert(pair(words[i], 1));
// }
}
vector<PAIR> result(word_map.begin(), word_map.end());
sort(result.begin(), result.end(), CmpByValue());
vector<string> ans; //不能使用ans(k)，会用默认值填充已分配的大小
for(int i=0;i<k;i++){
ans.push_back(result[i].first);
}
return ans;
}
};
备注：
1.对map,unordered_map {key,value}对的插入并且记录key的个数，可以采用直接数组的方式
map[key]++;如果有存在key，则会++，
如果不存在会直接创建，而不需要：
for(int i=0;i<words.size();i++){
map<string,int>::iterator iter;
iter = word_map.find(words[i]);
if(iter!=word_map.end()){
word_map[words[i]]++;
}else{
word_map.insert(pair<string, int>(words[i], 1));
}
}
直接
for(int i=0;i<words.size();i++){
word_map[words[i]]++;
}
对于map中存储的pair
2.auto使用，使得程序更加易懂和简洁
for(auto a:words){
word_map[a]++;
}
3.sort使用
要对STL的数据结构进行排序，使用sort方法，正常情况下需要重载函数,
有两种方法：
1.重写一个结构体：
typedef pair<string, int> PAIR;
struct CmpByValue {
bool operator()(const PAIR& lhs, const PAIR& rhs) {
if(lhs.second != rhs.second)
return lhs.second > rhs.second;
else{
return lhs.first < rhs.first;
}
}
};
2.重新定义一个函数：
typedef pair<string,int>node;
bool cmp(const node &a,const node &b){
if(a.second!=b.second)return a.second>b.second;
else return a.first<b.first;
}
使用时，可以用：
sort(result.begin(), result.end(), CmpByValue());
sort(result.begin(), result.end(), cmp);
注意，sort只能针对线性结构的数据结构来进行，因此，如果是需要对map，或unordered_map进行排序的话，需要先转换数据格式到如vector中去。
typedef pair<string, int> PAIR;
vector<PAIR> result(word_map.begin(), word_map.end());
函数需要用static，否则只能写在类的外部。
定义函数的时候sort(result.begin(), result.end(), cmp);不用加括号。
定义结构体的时候需要加括号，结构体可以写在类的内部，函数运算相对较快。
268. 缺失数字
给定一个包含 0, 1, 2, …, n 中 n 个数的序列，找出 0 … n 中没有出现在序列中的那个数。
第一种思路，排序，对应序号的数据如果没有对应该为，则为缺失的数据。
class Solution {
public:
int missingNumber(vector<int>& nums) {
sort(nums.begin(),nums.end());
int i=0;
for(auto a:nums){
if(a!=i){
break;
}
i++;
}
return i;
}
};
最简单的方法应该是求和，然后和1到n项的数列和对比，相差的数就是缺的这个数
0,1,2,3…这些数字求和直接用求和公式会循环的程序运行时间。
accumulate(nums.begin(),nums.end(),0)，STL模板函数API接口，可以
class Solution0 {
public:
int missingNumber(vector<int>& nums) {
int size_num=nums.size();
return size_num*(size_num+1)/2-accumulate(nums.begin(),nums.end(),0);
}
};
class Solution1 {
public:
int missingNumber(vector<int>& nums) {
int size_num=nums.size();
int sum_real=size_num;
int sum_prac=0;
for(int i=0;i<size_num;i++){
sum_prac+=nums[i];
}
return size_num*(size_num+1)/2-sum_prac;
}
};
class Solution2 {
public:
int missingNumber(vector<int>& nums) {
int size_num=nums.size();
int sum_real=size_num;
int sum_prac=0;
for(int i=0;i<size_num;i++){
sum_real+=i;
sum_prac+=nums[i];
}
return sum_real-sum_prac;
}
};