1
/**
* struct TreeNode {
*int val;
*struct TreeNode *left;
*struct TreeNode *right;
* };
*/
class Solution {
public:
/**
*
* @param root TreeNode类 the root
* @return bool布尔型vector
*/
vector judgeIt(TreeNode* root) {
// write code here
if (!root)
return {};
vector ans(2);
ans[0] = dfs(root);
ans[1] = bfs(root);
return ans;
}
bool dfs(TreeNode *root) {
if (!root)
return true;
if (root->left && root->left->val > root->val)
return false;
if (root->right && root->right->val val)
return false;
return dfs(root->left) && dfs(root->right);
}
bool bfs(TreeNode *root) {
queue q;
q.push(root);
//int level = 0;
while (!q.empty()) {
int nums = q.size();
//if (nums != pow(2, level++)) //这个是满二叉树的判断。。
// return false;
for (int i = 0; i
TreeNode *tmp = q.front();
q.pop();
if(!tmp->left && tmp->right) //左空有右肯定不是完全二叉树。。
return false;
if (tmp->left)
q.push(tmp->left);
if (tmp->right)
q.push(tmp->right);
}
}
return true;
}
};
编辑于 2021-02-08 12:02:37
回复(0)
1
/**
* struct TreeNode {
*int val;
*struct TreeNode *left;
*struct TreeNode *right;
* };
*/
class Solution {
public:
/**
*
* @param root TreeNode类 the root
* @return bool布尔型vector
*/
vector judgeIt(TreeNode* root) {
// write code here
vector v;
vector ans;
int flag = 0;
inorder(root, v,flag);
ans.push_back(flag==1?false:true);
ans.push_back(isCompleteTree(root));
return ans;
}
//判断二叉搜索树的依据是中序遍历一定是升序序列
void inorder(TreeNode* root,vector& v,int& flag){
if(flag) return;
if(root->left) inorder(root->left, v,flag);
if(!v.empty()&&root->val
v.push_back(root->val);
if(root->right) inorder(root->right, v,flag);
}
//bfs搜索，如果第一次遇到空节点之后又发现非空节点，则非完全二叉树
bool isCompleteTree(TreeNode* root){
if(!root) return true;
queue q;
q.push(root);
int flag = 0;
while(!q.empty()){
TreeNode* t = q.front();
q.pop();
if(t->left){
if(flag) return false;
else q.push(t->left);
}
else flag = 1;
if(t->right){
if(flag) return false;
else q.push(t->right);
}
else flag = 1;
}
return true;
}
};
发表于 2021-02-02 16:57:16
回复(0)
1
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
import java.util.Queue;
import java.util.LinkedList;
public class Solution {
/**
*
* @param root TreeNode类 the root
* @return bool布尔型一维数组
*/
public boolean[] judgeIt (TreeNode root) {
// write code here
boolean[] check = new boolean[2];
check[0] = isSearch(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
check[1] = isComplete(root);
return check;
}
public boolean isSearch(TreeNode root, int minVal, int maxVal){
if (root == null) return true;
boolean flag = (root.val >= minVal && root.val <= maxVal);
return flag && isSearch(root.left, minVal, root.val) && isSearch(root.right, root.val, maxVal);
}
public boolean isComplete(TreeNode root){
if (root == null) return true;
Queue queue = new LinkedList<>();
queue.offer(root);
boolean isLeaf = false;
while (!queue.isEmpty()){
int cnt = queue.size();
for(int i = 1;i <= cnt; ++i){
TreeNode now = queue.poll();
if (isLeaf && now.left != null) return false;
if (now.left == null && now.right != null) return false;
if (now.right == null) isLeaf = true;
if (now.left != null) queue.offer(now.left);
if (now.right != null) queue.offer(now.right);
}
}
return true;
}
}
发表于 2021-01-26 10:45:52
回复(0)
1
1.判断二叉搜索树
仅用左子树举例，注意左子树的所有结点比根小，不仅仅是左值
比如右子树的左子树，它不仅要小于父结点的值，还要大于根节点的值。
2.判断完全二叉树
四种情况递归(麻烦，不如用队列好) class Solution {
public:
/**
*
* @param root TreeNode类 the root
* @return bool布尔型vector
*/
bool bst(TreeNode* root,int mins,int maxs){
if(root==nullptr) return true;
if(root->val>maxs || root->val
return bst(root->left,mins,root->val)&&bst(root->right,root->val,maxs);
}
bool flag=true,legel=true;
int level(TreeNode* root){//保证右子树不比左子树低
if(root==nullptr) return 0;
if(root->left==nullptr && root->right!=nullptr) legel=false;
int lefthight=level(root->left);
int righthight=level(root->right);
if(lefthight
return righthight+1;
}
bool iscom(TreeNode* root){
if(root==nullptr) return true;
if(root->left==nullptr && root->right==nullptr)
flag=false;
else if(root->left!=nullptr && root->right==nullptr){
if(!flag) flag=false;
else return false;
}
else if(root->left==nullptr && root->right!=nullptr)
return false;
return iscom(root->left)&&iscom(root->right);
}
vector judgeIt(TreeNode* root) {
// write code here
vector res;
res.push_back(bst(root,INT_MIN,INT_MAX));
level(root);
if(!legel) res.push_back(false);
else res.push_back(iscom(root));
return res;
}
};
编辑于 2021-01-11 19:46:37
回复(2)
1
class Solution {
public:
vector judgeIt(TreeNode* root) {
// write code here
vector res{true,true};
if (!root) return res;
inOrder(root);
for(int i = 1;i
if (midSeq[i]
res[0] = false;
break;
}
res[1] = isComplete(root);
return res;
}
void inOrder(TreeNode* root) { //中序遍历
if (root == nullptr) return;
inOrder(root->left);
midSeq.emplace_back(root->val);
inOrder(root->right);
}
bool isComplete(TreeNode* root) {
queue q;
q.push(root);
while (!q.empty()) //层序遍历
{
int len = q.size();
for (int i = 0; i
TreeNode* temp = q.front();
if (temp->left && temp->right) { //左右孩子都有
q.push(temp->left);
q.push(temp->right);
q.pop();
}
else if (temp->right) return false; //只有右孩子
else{ //只有左孩子，或者叶子节点
if(temp->left) q.push(temp->left);
q.pop();
while (!q.empty()){ //其后须全是叶子节点
if (q.front()->left || q.front()->right) return false;
q.pop();
}
return true;
}
}
}
}
private:
vector midSeq;//中序遍历序列
};
这是一份可能不是最简洁，但可能最好懂的code。
首先，检查是否搜索二叉树，可以利用中序遍历，这里开辟了额外空间来存储，还额外地多了一次遍历检查是否有序。其实也可以在中序遍历的时候记录每个值，检查是否符合前一个比后一个小，这样时空开销会更小。
其次，完全二叉树的性质是除最后一层之外要求满，最后一层在左。层次遍历的过程中按节点的孩子节点分四种情况，其中左右孩子节点均有是常见的，有右孩子无左孩子违背了性质，有左孩子无右孩子或者达到叶子节点说明其后需全是叶子节点。
以上。
编辑于 2020-09-24 15:04:32
回复(0)
1
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
#
#
# @param root TreeNode类 the root
# @return bool布尔型一维数组
#
import collections
class Solution:
def judgeIt(self , root ):
# write code here
def dfs(root):
pre=-1
que=[]
while(que&nbs***bsp;root):
while(root):
que.append(root)
root=root.left
root=que.pop()
if pre>root.val:
return False
pre=root.val
root=root.right
return True
pre=root.val
return dfs(root.right)
def isfull(root):
que=collections.deque([root])
while(que):
c=que.popleft()
if not c:
while(que):
c=que.popleft()
if c:
return False
else:
que.append(c.left)
que.append(c.right)
return True
return [dfs(root),isfull(root)]
PY的代码，为了减少运行时间，都用的非递归实现，但是还是只能过84.21%，递归的方法只能74%。
我看大家通过的代码都是CPP的。。。 有点无奈
发表于 2020-09-18 14:02:44
回复(0)
1
class Solution {
public:
/**
*
* @param root TreeNode类 the root
* @return bool布尔型vector
*/
vector judgeIt(TreeNode* root) {
vector res{true,true};
if(root==NULL) return res;
//检测有序
vector nums;
func1(root,nums);
int cur=nums[0];
for(int i=1;i
if(cur>nums[i]){
res[0]=false;
}
}
//检测完全二叉树
vector cur_level{root};
res[1]=func2(cur_level);
return res;
}
void func1(TreeNode* root,vector& nums){
if(root==nullptr) return ;
func1(root->left, nums);
nums.push_back(root->val);
func1(root->right,nums);
return ;
}
bool func2(vector& cur_level){
int flag=true;
vector next_level;
for(int i=0;i
if(cur_level[i]!=nullptr){
if(flag==false){//如果前面出现过了空指针
return false;
}
next_level.push_back(cur_level[i]->left);
next_level.push_back(cur_level[i]->right);
}
else{//
flag=false;
}
}
if(next_level.size()==0) return true;
return func2(next_level);
}
}；
现场手撕就卡壳，面完复盘冷静下来就能写出来了，难受啊
发表于 2020-09-08 19:59:28
回复(0)
1
非递归
/**
* struct TreeNode {
*int val;
*struct TreeNode *left;
*struct TreeNode *right;
* };
*/
class Solution {
public:
/**
*
* @param root TreeNode类 the root
* @return bool布尔型vector
*/
bool judgeSearch(TreeNode* root){
if(root==nullptr)
return false;
TreeNode *p = root;
vector tmp;
stack s;
while(!s.empty() || p){
while(p){
s.push(p);
p = p->left;
}
if(!s.empty()){
p = s.top();
s.pop();
tmp.push_back(p->val);
p = p->right;
}
}
for(int i = 1; i
if(tmp[i]
return false;
return true;
}
bool judgeTotal(TreeNode *root){
if(root==nullptr)
return false;
TreeNode *p = root;
queue q;
q.push(root);
while(!q.empty()){
p = q.front();
q.pop();
if(p->left && p->right){
q.push(p->left);
q.push(p->right);
}
else if(p->left==nullptr && p->right)
return false;
else{
if(p->left && p->right==nullptr)
while(!q.empty()){
p = q.front();
q.pop();
if(p->left || p->right)
return false;
}
}
}
return true;
}
vector judgeIt(TreeNode* root) {
// write code here
vector res;
res.push_back(judgeSearch(root));
res.push_back(judgeTotal(root));
return res;
}
};
发表于 2020-09-08 10:48:35
回复(3)
0
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类 the root
* @return bool布尔型一维数组
*/
public boolean[] judgeIt (TreeNode root) {
// write code here
boolean[] res = new boolean[2];
res[0] = judgeBST(root);
res[1] = judgeCBT(root);
return res;
}
private boolean judgeBST(TreeNode root) {
if(root == null) {
return true;
}
if(root.left != null && root.left.val > root.val) return false;
if(root.right != null && root.right.val
boolean left = judgeBST(root.left);
boolean right = judgeBST(root.right);
return left && right;
}
private boolean judgeCBT(TreeNode root) {
Queue queue = new LinkedList<>();
if(root == null) return true;
queue.offer(root);
TreeNode node = null;
while(!queue.isEmpty()) {
node = queue.poll();
if(node == null) {
break;
}
queue.offer(node.left);
queue.offer(node.right);
}
while(!queue.isEmpty()) {
node = queue.poll();
if(node != null) {
return false;
}
}
return true;
}
}
发表于 2021-02-26 17:12:58
回复(0)
0
/**
* struct TreeNode {
*int val;
*struct TreeNode *left;
*struct TreeNode *right;
* };
*/
class Solution {
public:
/**
*
* @param root TreeNode类 the root
* @return bool布尔型vector
*/
vector judgeIt(TreeNode* root) {
// write code here
judge.push_back(true);
judge.push_back(true);
h=0;
flag=0;
MidFS(root);
return judge;
}
void MidFS(TreeNode* root){
if(root!=NULL){
h++;
MidFS(root->left);
if(!Midlist.empty()&&root->val
judge[0]=false;
}
Midlist.push_back(root->val);
if(root->left==NULL||root->right==NULL){
if(root->left==NULL&&root->right==NULL){
if(H.empty()){
H.push_back(h);
maxh=h;
}
else{
int lefth=H[H.size()-1];
if(h==maxh){
if(h>lefth){
judge[1]=false;
}
}
else if(h
judge[1]=false;
}
H.push_back(h);
}
}
else{
if(root->left==NULL||flag==1){
judge[1]=false;
}
else{
flag=1;
}
}
}
MidFS(root->right);
h--;
}
}
private:
vector Midlist; //中序遍历序列
vector judge;
int h,maxh,flag; //树的高度
vector H; //储存树的高度
};
编辑于 2021-02-26 13:24:43
回复(0)
0
/**
* struct TreeNode {
*int val;
*struct TreeNode *left;
*struct TreeNode *right;
* };
*/
class Solution {
public:
/**
*
* @param root TreeNode类 the root
* @return bool布尔型vector
*/
vector judgeIt(TreeNode* root) {
// write code here
return {isSearchTree(root,INT_MIN,INT_MAX),isCompletedTree(root)};
}
bool isCompletedTree(TreeNode* root)
{
if(root == nullptr)
return true;
if(root->left && root->right == nullptr)
return isCompletedTree(root->left);
if(root->left == nullptr && root->right)
return false;
return isCompletedTree(root->left) && isCompletedTree(root->right);
}
bool isSearchTree(TreeNode *root, int left, int right)
{
if(root == nullptr)
return true;
if(root->val val > right)
return false;
return isSearchTree(root->left,left,root->val) && isSearchTree(root->right, root->val,right);
}
};
发表于 2021-02-26 11:49:55
回复(0)
0
/**
* struct TreeNode {
*int val;
*struct TreeNode *left;
*struct TreeNode *right;
* };
*/
class Solution {
public:
/**
*
* @param root TreeNode类 the root
* @return bool布尔型vector
*/
vector judgeIt(TreeNode* root) {
// write code here
vectorans;
ans.push_back(dfs(root));
ans.push_back(bfs(root));
return ans;
}
bool dfs(TreeNode* root)
{
if(root == nullptr)
return true;
if(root ->left != nullptr && root ->left ->val > root ->val)
return false;
if(root ->right != nullptr && root ->right->val val)
return false;
return dfs(root ->left) && dfs(root ->right);
}
bool bfs(TreeNode* root)
{
if(root == nullptr)
return false;
queue q;
q.push(root);
while(!q.empty())
{
TreeNode* n = q.front();
q.pop();
if(n ->left && n->right)
{
q.push(n ->left);
q.push(n ->right);
}
else if(n ->left == nullptr && n ->right)
{
return false;
}
else
{
// 如果n 只有left节点，要确保n之后全是叶子节点,
// 否则标记之后的顺序和满二叉树不一致，即不是完全二叉树
if(n ->left != nullptr && n ->right == nullptr)
{
while(!q.empty())
{
TreeNode* p = q.front();
q.pop();
if(p ->left || p->right)
return false;
}
}
}
}
return true;
}
};
发表于 2021-02-20 15:55:37
回复(0)
0
boolean[] res={true,true};
public boolean[] judgeIt (TreeNode root) {
if (root==null) return res;
if (root.left==null&&root.right!=null&&root.right.val
res[0]=false;
res[1]=false;
}
if(root.left!=null&&root.right==null&&root.left.val>root.val){
res[0]=false;
}
if (root.left!=null&&root.right!=null){
if (root.left.val>root.val||root.right.val
}
judgeIt(root.left);
judgeIt(root.right);
return res;
编辑于 2021-02-12 12:08:38
回复(0)
0
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类 the root
* @return bool布尔型一维数组
*/
public boolean[] judgeIt (TreeNode root) {
boolean[]res={judgeSearchTree(root),isComplete(root)};
return res;
}
// 二叉搜索树：每个节点左边节点小于右边节点，左子树的最大值一定小于根节点，小于右子树的最大值；
//通过中序遍历，严格递增
public boolean judgeSearchTree(TreeNode root){
ArrayList list=new ArrayList();
midSearch(root,list);
for(int i=1;i
if(list.get(i)
}
return true;
}
public void midSearch(TreeNode root, ArrayListlist){
if(root==null) return;
midSearch(root.left,list);
list.add(root.val);
midSearch(root.right,list);
}
// 完全二叉树:层序遍历，主要分四种情况：
//左右孩子都有、只有左孩子、只有右孩子、叶子节点
public boolean isComplete(TreeNode root){
if(root==null) return true;
Queuequeue=new LinkedList();
queue.add(root);
while(!queue.isEmpty()){
int size=queue.size();
for(int i=0;i
TreeNode node=queue.poll();
if(node.left!=null&&node.right!=null){
queue.add(node.left);
queue.add(node.right);
}
else if(node.right!=null) return false;//只有右孩子，不是完全子树
else{//只有左孩子或者是叶子节点
if(node.left!=null) queue.add(node.left);
//后面只能是叶子节点
while(!queue.isEmpty()){
TreeNode node1=queue.poll();
if(node1.left!=null||node1.right!=null) return false;
}
return true;//不用再继续处理了
}
}
}
return true;
}
}
发表于 2021-02-04 19:15:04
回复(0)
0
/**
* struct TreeNode {
*int val;
*struct TreeNode *left;
*struct TreeNode *right;
* };
*/
class Solution {
public:
/**
*
* @param root TreeNode类 the root
* @return bool布尔型vector
*/
vector judgeIt(TreeNode* root) {
// write code here
vector res;
res.push_back(isSearch(root));
res.push_back(isFull(root));
return res;
}
bool isSearch(TreeNode*root){
if(root==nullptr){return true;}
if(root->left==nullptr&&root->right==nullptr){
return true;
}
if(root->left==nullptr){
if(root->valright->val){
return isSearch(root->right);
}else{return false;}
}
if(root->right==nullptr){
if(root->val > root->left->val){
return isSearch(root->left);
}else{return false;}
}
if(root->left->valval&&root->valright->val){
return isSearch(root->left)&&isSearch(root->right);
}return false;
}
bool isFull(TreeNode*root){
if(root==nullptr){return true;}
queue aux;
bool flag=0;
aux.push(root);
TreeNode* cur=root;
while(!aux.empty()){
cur=aux.front();
if(cur->left!=nullptr){aux.push(cur->left);}
if(cur->right!=nullptr){aux.push(cur->right);}
if(cur->left==nullptr&&cur->right!=nullptr){return false;}
if(flag==1&&(cur->left!=nullptr||cur->right!=nullptr)){
return false;
}
if(cur->right==nullptr||cur->left==nullptr){flag=1;
//flag标准出现左右子节点为空的节点，之后不可再出现非页节点}
aux.pop();
}
return true;
}
};
通过了94%，求大佬看一下哪里出了问题
发表于 2021-01-22 21:46:49
回复(0)
0
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
#
#
# @param root TreeNode类 the root
# @return bool布尔型一维数组
#
class Solution:
def judgeIt(self , root ):
# write code here
return [False,False]
呃呃呃，为什么我就返回两个bool值都能超时啊。。。阿这。。。
发表于 2021-01-18 22:58:02
回复(0)
0
//判断搜索树借鉴了大佬经验，均使用递归，平衡树若有bug敬请指正
public class Solution { /**
*
* @param root TreeNode类 the root
* @return bool布尔型一维数组
*/
int temp = -1;
public boolean[] judgeIt (TreeNode root) {
// write code here
boolean []result = new boolean[2];
result[0]= sel(root);
int i =wandel(root);
if(i==0||i==1){
result[1] = true;
}else{
result[1] = false;
}
return result;
}
boolean sel(TreeNode root){
if(root==null){ return true;}
if(!sel(root.left)){return false;}
if(root.val<=temp){
return false;
}
temp = root.val;
return sel(root.right);
}
int wandel(TreeNode root){
if(root == null){return 0;}
if(root.left==null&&root.right!=null){
return -100;
}
int left = wandel(root.left)+1;
int right = wandel(root.right)+1;
return left-right;
}
}
发表于 2021-01-18 20:54:26
回复(0)
0
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类 the root
* @return bool布尔型一维数组
*/
/**
* 假设一个二叉搜索树具有如下特征：
*
* 节点的左子树只包含小于当前节点的数。
* 节点的右子树只包含大于当前节点的数。
* 所有左子树和右子树自身必须也是二叉搜索树。
* 2
*. 1. 3
* 是二叉搜索树
* 1
* 2 3
* 非二叉搜索树
*
*思路：中序遍历的结果是从小到大排列，故采用中序遍历，对节点值进行比较，如果出现当前节点值小于前一个节点值则不是二叉搜索树。
*/
//是否是二叉搜索树
boolean isBstTreeFlg = true;
//上一个节点值
int preNodeVal = Integer.MIN_VALUE;
public boolean[] judgeIt (TreeNode root) {
boolean[] result = new boolean[2];
if(root == null){
result[0] = true;
result[1] = true;
return result;
}
isBstTree(root);
result[0] = isBstTreeFlg;
result[1] = isCompleteTree(root);
return result;
}
//中序遍历
public void isBstTree(TreeNode root){
if(root == null || !isBstTreeFlg){
return;
}
isBstTree(root.left);
if(root.val > preNodeVal){
preNodeVal = root.val;
}else{
//中序遍历 如:2 1 3 2节点
isBstTreeFlg = false;
return;
}
isBstTree(root.right);
}
public boolean isCompleteTree(TreeNode root){
if(root == null){
return false;
}
// 1. 先对树进行层序遍历
// 如果这个标记为 false, 说明还是处在第一阶段
// 如果这个标记为 true , 接下来的节点就不能有子树
// 也就是第二阶段开始了
int flg = 1;//第一阶段:1 第二阶段:2
LinkedList queue = new LinkedList();
queue.add(root);
while(!queue.isEmpty()){
TreeNode temp = queue.poll();
if(flg == 1){
// 合格的状态, 继续往下遍历.
// 就把左右子树加入队列就行了
if(temp.left != null && temp.right != null){
queue.offer(temp.left);
queue.offer(temp.right);
}else if(temp.left == null && temp.right != null){
// 这种情况铁定不是完全二叉树
return false;
}else if(temp.left != null && temp.right == null){
// 这是临界状态, 开启第二阶段
queue.offer(temp.left);
//开启第二阶段
flg = 2;
}
//else{这种情况不用判断
// 左右子树都为空, 开启第二阶段
// flg = 2;
//}
}else{
//开启第二阶段
// 第二阶段要求节点必须没有子树. 只要子树存在, 就不是完全二叉树
if(temp.left != null || temp.right != null){
return false;
}
}
}
return true;
}
}
编辑于 2021-01-19 15:40:15
回复(0)
0
牛客是真的狗，明明两道题合成一道题，偷懒界的标杆啊
import java.util.*;
public class Solution {
private long pre = Long.MIN_VALUE;
public boolean[] judgeIt (TreeNode root) {
boolean[] res = new boolean[2];
res[0] = judgeBST(root);
res[1] = judgeCBT(root);
return res;
}
public boolean judgeBST(TreeNode root) {
if (root == null) {
return true;
}
if (!judgeBST(root.left)) {
return false;
}
if (root.val <= pre) {
return false;
}
pre = root.val;
return judgeBST(root.right);
}
public boolean judgeCBT(TreeNode root) {
if (root == null) {
return true;
}
Queue queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
boolean flag = false;
int n = queue.size();
for (int i = 0;i
TreeNode node = queue.poll();
if (node.left != null || node.right != null) {
if (flag) {
return false;
}
}
if (node.left != null) {
queue.offer(node.left);
}else {
flag = true;
}
if (node.right != null) {
queue.offer(node.right);
}else {
flag = true;
}
}
}
return true;
}
}
发表于 2021-01-11 12:17:53
回复(0)
0
function judgeIt( root ) {
// write code here
//中序遍历 二叉搜索数 左子树<=当前节点<=右子树
//完全二叉树：除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置
function isSearch(root,min=-Infinity,max=Infinity){//限定每个节点的范围
if(!root) return true;
if(root.val<=min||root.val >= max) return false
return isSearch(root.left,min,root.val)&&isSearch(root.right,root.val,max)
}
function isComplete(root){
if(!root) return true;
if(!root.left&&root.right) return false
return isComplete(root.left)&&isComplete(root.right)
}
return [isSearch(root),isComplete(root)]//(这种判断完全二叉树的方法是错误的吧)怎么还能通过
}
编辑于 2021-01-08 15:21:11
回复(0)
137
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
