检查二叉树是否按级别排序
给定一棵二叉树。任务是检查二叉树是否按级别排序。如果 max( i-1 th level ) 小于 min( i th level )，则对二叉树进行级别排序。
例子：
Input : 1
/ \
/ \
2 3
/ \ / \
/ \ / \
4 5 6 7
Output : Sorted
Input: 1
/
4
/ \
6 5
\
2
Output: Not sorted简单的解决方案：一个简单的解决方案是比较每个相邻级别 i 和 i+1 的最小值和最大值。遍历第 i层和第i +1 层，比较第 i+1 层的最小值和第i层的最大值并返回结果。
时间复杂度：O(n 2 )。
有效的解决方案：一个有效的解决方案是进行级别顺序遍历并跟踪当前级别的最小值和最大值。使用变量prevMax来存储前一级别的最大值。然后将当前级别的最小值与前一级别的最大值pevMax 进行比较。如果最小值大于prevMax ，则给定的树按级别排序到当前级别。对于下一个级别， prevMax等于当前级别的最大值。所以用当前级别的最大值更新prevMax 。重复此操作，直到不遍历给定树的所有级别。
以下是上述方法的实现：
C++
// CPP program to determine whether
// binary tree is level sorted or not.
#include
using namespace std;
// Structure of a tree node.
struct Node {
int key;
Node *left, *right;
};
// Function to create new tree node.
Node* newNode(int key)
{
Node* temp = new Node;
temp->key = key;
temp->left = temp->right = NULL;
return temp;
}
// Function to determine if
// given binary tree is level sorted
// or not.
int isSorted(Node* root)
{
// to store maximum value of previous
// level.
int prevMax = INT_MIN;
// to store minimum value of current
// level.
int minval;
// to store maximum value of current
// level.
int maxval;
// to store number of nodes in current
// level.
int levelSize;
// queue to perform level order traversal.
queue q;
q.push(root);
while (!q.empty()) {
// find number of nodes in current
// level.
levelSize = q.size();
minval = INT_MAX;
maxval = INT_MIN;
// traverse current level and find
// minimum and maximum value of
// this level.
while (levelSize > 0) {
root = q.front();
q.pop();
levelSize--;
minval = min(minval, root->key);
maxval = max(maxval, root->key);
if (root->left)
q.push(root->left);
if (root->right)
q.push(root->right);
}
// if minimum value of this level
// is not greater than maximum
// value of previous level then
// given tree is not level sorted.
if (minval <= prevMax)
return 0;
// maximum value of this level is
// previous maximum value for
// next level.
prevMax = maxval;
}
return 1;
}
// Driver program
int main()
{
/*
1
/
4
\
6
/ \
8 9
/ \
12 10
*/
Node* root = newNode(1);
root->left = newNode(4);
root->left->right = newNode(6);
root->left->right->left = newNode(8);
root->left->right->right = newNode(9);
root->left->right->left->left = newNode(12);
root->left->right->right->right = newNode(10);
if (isSorted(root))
cout << "Sorted";
else
cout << "Not sorted";
return 0;
} Java
// Java program to determine whether
// binary tree is level sorted or not.
import java.util.*;
class GfG {
// Structure of a tree node.
static class Node {
int key;
Node left, right;
}
// Function to create new tree node.
static Node newNode(int key)
{
Node temp = new Node();
temp.key = key;
temp.left = null;
temp.right = null;
return temp;
}
// Function to determine if
// given binary tree is level sorted
// or not.
static int isSorted(Node root)
{
// to store maximum value of previous
// level.
int prevMax = Integer.MIN_VALUE;
// to store minimum value of current
// level.
int minval;
// to store maximum value of current
// level.
int maxval;
// to store number of nodes in current
// level.
int levelSize;
// queue to perform level order traversal.
Queue q = new LinkedList ();
q.add(root);
while (!q.isEmpty()) {
// find number of nodes in current
// level.
levelSize = q.size();
minval = Integer.MAX_VALUE;
maxval = Integer.MIN_VALUE;
// traverse current level and find
// minimum and maximum value of
// this level.
while (levelSize > 0) {
root = q.peek();
q.remove();
levelSize--;
minval = Math.min(minval, root.key);
maxval = Math.max(maxval, root.key);
if (root.left != null)
q.add(root.left);
if (root.right != null)
q.add(root.right);
}
// if minimum value of this level
// is not greater than maximum
// value of previous level then
// given tree is not level sorted.
if (minval <= prevMax)
return 0;
// maximum value of this level is
// previous maximum value for
// next level.
prevMax = maxval;
}
return 1;
}
// Driver program
public static void main(String[] args)
{
/*
1
/
4
\
6
/ \
8 9
/ \
12 10
*/
Node root = newNode(1);
root.left = newNode(4);
root.left.right = newNode(6);
root.left.right.left = newNode(8);
root.left.right.right = newNode(9);
root.left.right.left.left = newNode(12);
root.left.right.right.right = newNode(10);
if (isSorted(root) == 1)
System.out.println("Sorted");
else
System.out.println("Not sorted");
}
} Python3
# Python3 program to determine whether
# binary tree is level sorted or not.
from queue import Queue
# Function to create new tree node.
class newNode:
def __init__(self, key):
self.key = key
self.left = self.right = None
# Function to determine if given binary
# tree is level sorted or not.
def isSorted(root):
# to store maximum value of previous
# level.
prevMax = -999999999999
# to store minimum value of current
# level.
minval = None
# to store maximum value of current
# level.
maxval = None
# to store number of nodes in current
# level.
levelSize = None
# queue to perform level order traversal.
q = Queue()
q.put(root)
while (not q.empty()):
# find number of nodes in current
# level.
levelSize = q.qsize()
minval = 999999999999
maxval = -999999999999
# traverse current level and find
# minimum and maximum value of
# this level.
while (levelSize > 0):
root = q.queue[0]
q.get()
levelSize -= 1
minval = min(minval, root.key)
maxval = max(maxval, root.key)
if (root.left):
q.put(root.left)
if (root.right):
q.put(root.right)
# if minimum value of this level
# is not greater than maximum
# value of previous level then
# given tree is not level sorted.
if (minval <= prevMax):
return 0
# maximum value of this level is
# previous maximum value for
# next level.
prevMax = maxval
return 1
# Driver Code
if __name__ == '__main__':
#
# 1
# /
# 4
# \
# 6
# / \
# 8 9
# / \
# 12 10
root = newNode(1)
root.left = newNode(4)
root.left.right = newNode(6)
root.left.right.left = newNode(8)
root.left.right.right = newNode(9)
root.left.right.left.left = newNode(12)
root.left.right.right.right = newNode(10)
if (isSorted(root)):
print("Sorted")
else:
print("Not sorted")
# This code is contributed by PranchalKC#
// C# program to determine whether
// binary tree is level sorted or not.
using System;
using System.Collections.Generic;
class GFG
{
// Structure of a tree node.
public class Node
{
public int key;
public Node left, right;
}
// Function to create new tree node.
static Node newNode(int key)
{
Node temp = new Node();
temp.key = key;
temp.left = null;
temp.right = null;
return temp;
}
// Function to determine if
// given binary tree is level sorted
// or not.
static int isSorted(Node root)
{
// to store maximum value of previous
// level.
int prevMax = int.MinValue;
// to store minimum value of current
// level.
int minval;
// to store maximum value of current
// level.
int maxval;
// to store number of nodes in current
// level.
int levelSize;
// queue to perform level order traversal.
Queue q = new Queue ();
q.Enqueue(root);
while (q.Count != 0)
{
// find number of nodes in current
// level.
levelSize = q.Count;
minval = int.MaxValue;
maxval = int.MinValue;
// traverse current level and find
// minimum and maximum value of
// this level.
while (levelSize > 0)
{
root = q.Peek();
q.Dequeue();
levelSize--;
minval = Math.Min(minval, root.key);
maxval = Math.Max(maxval, root.key);
if (root.left != null)
q.Enqueue(root.left);
if (root.right != null)
q.Enqueue(root.right);
}
// if minimum value of this level
// is not greater than maximum
// value of previous level then
// given tree is not level sorted.
if (minval <= prevMax)
return 0;
// maximum value of this level is
// previous maximum value for
// next level.
prevMax = maxval;
}
return 1;
}
// Driver Code
public static void Main(String[] args)
{
/*
1
/
4
\
6
/ \
8 9
/ \
12 10
*/
Node root = newNode(1);
root.left = newNode(4);
root.left.right = newNode(6);
root.left.right.left = newNode(8);
root.left.right.right = newNode(9);
root.left.right.left.left = newNode(12);
root.left.right.right.right = newNode(10);
if (isSorted(root) == 1)
Console.WriteLine("Sorted");
else
Console.WriteLine("Not sorted");
}
}
// This code is contributed by PrinciRaj1992 Javascript
输出：
Sorted时间复杂度： O(n)
辅助空间： O(n)