34.
/*
// Definition for a Node.
class Node {
public:
int val;
Node* left;
Node* right;
Node() {}
Node(int _val) {
val = _val;
left = NULL;
right = NULL;
}
Node(int _val, Node* _left, Node* _right) {
val = _val;
left = _left;
right = _right;
}
};
*/
class Solution {
public:
Node * head=NULL;
Node* pre=NULL;
Node * tail=NULL;
void inorder1(Node* root){
if(!root){
return;
}
inorder1(root->left);
if(pre==NULL){//第一个元素
head=root;
}
else{
pre->right=root;//连接后继
}
root->left=pre;//连接前驱
pre=root;//指向新的节点
tail=root;
inorder1(root->right);
return;
}
Node* treeToDoublyList(Node* root){
if(!root){
return root;
}
inorder1(root);//中序遍历为元素递增排列
head->left=tail;
tail->right=head;
return head;
}
};
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Codec {
public:
// Encodes a tree to a single string.
string serialize(TreeNode* root) {
string res="";
queue<TreeNode*> q;//基于队列层次遍历
q.push(root);
while (!q.empty()) {
TreeNode* temp = q.front();
q.pop();
if (temp) {
res+=to_string(temp->val);//变为字符串
res+=" ";
q.push(temp->left);
q.push(temp->right);
} else {
res+="null ";
}
}
return res;
}
// Decodes your encoded data to tree.通过序列建树(leetcode算法)
TreeNode* deserialize(string data) {
istringstream input(data);//它的作用是从string对象data中读取字符
string val;
vector<TreeNode*> vec;
while (input >> val) {//读取的字符
if (val == "null") {
vec.push_back(NULL);
} else {
vec.push_back(new TreeNode(stoi(val)));//stoi,把字符串转换为十进制数
}
}
int j = 1; // i每往后移动一位,j移动两位,j始终是当前i的左子下标
for (int i = 0; j < vec.size(); ++i) { // 肯定是j先到达边界,所以这里判断j < vec.size()
if (vec[i] == NULL) continue; // vec[i]为null时跳过。
if (j < vec.size()) vec[i]->left = vec[j++]; // 当前j位置为i的左子树
if (j < vec.size()) vec[i]->right = vec[j++]; // 当前j位置为i的右子树
}
return vec[0];
}
};
// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));
36.全排列(dfs)
class Solution {
public:
vector<string> result;
vector<string> permutation(string s) {
dfs(s, 0);
return result;
}
void dfs(string& s, int pos) {
if (pos >= s.size()) {
result.push_back(s);
return;
}
for (int i = pos; i < s.size(); ++i) {
if (judge(s, pos, i)) continue; // 如果pos和i之间有字符等于s[i],则跳过。
swap(s[pos], s[i]);
dfs(s, pos+1);
swap(s[pos], s[i]);
}
}
bool judge(string& s, int start, int end) {
for (int i = start; i < end; ++i) {
if (s[i] == s[end]) return true;
}
return false;
}
};
/**
* 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:
vector<vector<int>> res;
vector<int> arr;
vector<vector<int>> pathSum(TreeNode* root, int sum) {
dfs(root,sum);
return res;
}
void dfs(TreeNode* root, int sum){
if(root==nullptr){
return ;
}
arr.push_back(root->val);//根
sum-=root->val;//sum 在调用的子函数中是改变的
if(root->left==nullptr&&root->right==nullptr&&sum==0){//到达叶子节点
res.push_back(arr);
}
dfs(root->left,sum);
dfs(root->right,sum);
arr.pop_back();//将之前记录的路径清空 方便下一次记录
}
};
class Solution {//从个位遍历到最高位
public:
int countDigitOne(int n) {
int count = 0;
long i = 1;//指向遍历的位数,如i=1即个位,i=10即十位,...,因为n可以有31位,所以10^31用long存储
while(n/i!=0){
//n/i控制遍历的次数,将所有的位数都遍历完毕
long high = n/(10*i);//将当前位之前的所有高位都存在high中
long cur = (n/i)%10;//将当前位记录在cur中,即我们每次都需要统计当前位上1出现的次数
long low = n-(n/i)*i;
if(cur == 0){//假设高位为high,当前位为cur,低位为low,i代表着需要统计的位置数(1/ //对应个位,10对应十位,100对应百位),则对每一位的个数count有:
//cur=0,count = high*i;
//cur=1,count=high*i+low+1;
//cur>1,count=high*i+i
count += high * i;
} else if(cur == 1){
count += high * i + low + 1;
} else {
count += high * i + i;
}
i = i * 10;//准备遍历下一位
}
return count;
}
};