标签:
class
TreeToSequence
{
public
:
void
preOrder(TreeNode*
root,vector<
int
>
&pre) {
if
(!root)
return
;
pre.push_back(root->val);
preOrder(root->left,pre);
preOrder(root->right,pre);
}
void
inOrder(TreeNode*
root,vector<
int
>
&in) {
if
(!root)
return
;
inOrder(root->left,in);
in.push_back(root->val);
inOrder(root->right,in);
}
void
postOrder(TreeNode*
root,vector<
int
>
&post) {
if
(!root)
return
;
postOrder(root->left,post);
postOrder(root->right,post);
post.push_back(root->val);
}
vector<vector<
int
>
> convert(TreeNode* root) {
vector<vector<
int
>
> vRecur;
vector<
int
>
pre,in,post;
preOrder(root,pre);
inOrder(root,in);
postOrder(root,post);
vRecur.push_back(pre);
vRecur.push_back(in);
vRecur.push_back(post);
return
vRecur;
}
};
class
CheckCompletion
{
public
:
bool
chk(TreeNode* root) {
queue<TreeNode*>
q;
q.push(root);
int
n
=
0
;
while
(!q.empty())
{
TreeNode*
temp = q.front();
q.pop();
if
(!temp->left
&& temp->right)
return
false
;
if
(temp->left
&& temp->right) {
q.push(temp->left);
q.push(temp->right);
}
if
(temp->left
&& !temp->right) {
if
(temp->left->left
|| temp->left->right)
return
false
;
n++;
if
(n
>
1
)
return
false
;
q.push(temp->left);
}
}
return
true
;
}
};
class
FoldPaper
{
public
:
vector<string>
foldPaper(
int
n)
{
vector<string>
ret;
foldPrint(
"down"
,
ret, n);
return
ret;
}
void
foldPrint(string
fold, vector<string>& ret,
int
remain){
if
(remain
==
0
)
return
;
foldPrint(
"down"
,
ret, remain -
1
);
ret.push_back(fold);
foldPrint(
"up"
,
ret, remain -
1
);
}
};
class
FoldPaper
{
public
:
vector<string>
foldPaper(
int
n)
{
string
sLeft[] = {
"down"
,
"down"
,
"up"
};
string
sRight[] = {
"down"
,
"up"
,
"up"
};
vector<string>
lS(sLeft,sLeft+
3
);
vector<string>
rS(sRight,sRight+
3
);
vector<string>
last,odd,even = lS;
odd.push_back(
"down"
);
if
(n
==
1
)
{
return
odd;
}
if
(n
==
2
)
{
return
even;
}
int
i;
if
(n%
2
==
1
)
{
i
=
3
;
last
= odd;
}
else
{
i
=
4
;
last
= even;
}
vector<string>
res;
vector<string>::iterator
iter;
for
(;i
<= n;) {
iter
= last.begin();
while
(iter
< last.end()) {
res.insert(res.end(),lS.begin(),lS.end());
res.push_back(*iter);
res.insert(res.end(),rS.begin(),rS.end());
if
(iter
< last.end()-
1
)
res.push_back(*(iter+
1
));
iter
= iter+
2
;
}
last.swap(res);
res.clear();
i
= i+
2
;
}
return
last;
}
};
class
LongestDistance
{
public
:
vector<
int
>
postVisit(TreeNode* root) {
vector<
int
>
resL,resR,res;
if
(!root)
{ // 如果当前节点为空,则以它为根节点的树中最大距离和最远距离都为0
res.push_back(
0
);
res.push_back(
0
);
return
res;
}
// 若不空则先后处理左右子树,返回左右子树的最大距离和最远距离
resL
= postVisit(root->left);
resR
= postVisit(root->right);
// 计算以当前结点为根节点的树的最大距离和最远距离
int
max1
= resL[
0
],max2;
if
(resR[
0
]
> max1)
max1
= resR[
0
];
if
(resL[
1
]+resR[
1
]+
1
>
max1)
max1
= resL[
1
]+resR[
1
]+
1
;
max2
= resL[
1
]>resR[
1
]?resL[
1
]+
1
:resR[
1
]+
1
;
res.push_back(max1);
res.push_back(max2);
return
res;
}
int
findLongest(TreeNode*
root) {
vector<
int
>
max = postVisit(root);
return
max[
0
];
}
};
class
MaxSubtree
{
public
:
typedef
struct {
vector<
int
>
num;
TreeNode*
rMax;
}
Dataset;
Dataset
postVisit(TreeNode* root) {
Dataset
datal,datar,data;
if
(!root)
{
data.num.insert(data.num.begin(),3,0);
data.rMax
= NULL;
return
data;
}
datal
= postVisit(root->left);
datar
= postVisit(root->right);
if
(root->left
&& root->right) {
if
(datal.rMax
== root->left &&
datar.rMax
== root->right &&
datal.num[
2
]
< root->val &&
datar.num[
1
]
> root->val) {
data.rMax
= root;
data.num.push_back(datal.num[
0
]+datar.num[
0
]+
1
);
data.num.push_back(datal.num[
1
]<datar.num[
1
]?datal.num[
1
]:datar.num[
1
]);
data.num.push_back(datal.num[
2
]<datar.num[
2
]?datar.num[
2
]:datal.num[
2
]);
}
else
{
if
(datal.num[
0
]>datar.num[
0
])
data
= datal;
else
if
(datal.num[
0
]<datar.num[
0
])
data
= datar;
else
data
= datal.rMax->val > datar.rMax->val?datal:datar;
}
}
else
if
(!root->left
&& !root->right) {
data.rMax
= root;
data.num.push_back(datal.num[
0
]+datar.num[
0
]+
1
);
data.num.push_back(root->val);
data.num.push_back(root->val);
}
else
if
(!root->left)
{
if
(datar.num[
1
]
> root->val && datar.rMax == root->right) {
data.rMax
= root;
data.num.push_back(datal.num[
0
]+datar.num[
0
]+
1
);
data.num.push_back(root->val);
data.num.push_back(datar.num[
2
]);
}
else
data
= datar;
}
else
{
if
(datal.num[
2
]
< root->val && datal.rMax == root->left) {
data.rMax
= root;
data.num.push_back(datal.num[
0
]+datar.num[
0
]+
1
);
data.num.push_back(datal.num[
1
]);
data.num.push_back(root->val);
}
else
data
= datal;
}
return
data;
}
TreeNode*
getMax(TreeNode* root) {
Dataset
resData = postVisit(root);
return
resData.rMax;
}
};
class
MaxSubtree
{
public
:
bool
chk[
550
];
void
get(TreeNode*
rt,
int
*mn,
int
*mx,
int
*sz,TreeNode
*&ret,
int
&msz){
int
v
= rt->val;
mn[v]
=
10101010
;
mx[v] =
0
;
chk[v]
=
false
;
int
lsz
=
0
,rsz
=
0
,lmx
=
0
,rmx
=
0
,lmn
=
10101010
,rmn
=
10101010
;
bool
cl =
true
,cr
=
true
;
if
(rt->left)
get(rt->left,mn,mx,sz,ret,msz),lsz = sz[rt->left->val],lmn = mn[rt->left->val],lmx = mx[rt->left->val],cl = chk[rt->left->val];
if
(rt->right)
get(rt->right,mn,mx,sz,ret,msz),rsz = sz[rt->right->val],rmn = mn[rt->right->val],rmx = mx[rt->right->val],cr = chk[rt->right->val];
if
(lsz
!= -
1
&&
rsz != -
1
){
if
(cl
&& cr && lmx < v && v < rmn){
int
tmp
= lsz + rsz +
1
;
chk[v]
=
true
;
if
(tmp
> msz || (tmp == msz && ret->val < v)){
ret
= rt; msz = tmp;
}
}
sz[v]
= lsz + rsz +
1
;
mx[v]
= max(v,lmx);
mn[v]
= min(v,lmn);
}
}
TreeNode*
getMax(TreeNode* root) {
TreeNode*
ret = NULL;
int
mn[
550
],mx[
550
],sz[
550
],msz
=
0
;
get(root,mn,mx,sz,ret,msz);
return
ret;
}
};
标签:
原文地址:http://blog.csdn.net/djangobuaa/article/details/51105640