给定二叉树中奇数级和偶数级叶子和之间的差异
给定一棵二叉树，任务是找出给定树的奇数层和偶数层叶子节点之和的差值。
例子：
Input:
Output: -12
Explanation: Following are the operations performed to get the result.
odd_level_sum = 0, even_level_sum = 0
Level 1: No leaf node, so odd_level_sum = 0
Level 2: No leaf node, so even_level_sum = 0
Level 3: One leaf node: 6, so odd_level_sum = 0 + 6 = 6
Level 4: Three leaf nodes: 9, 10, 11, so even_level_sum = 0 + 9 + 10 + 11 = 30
Level 5: One leaf node: 12, so odd_level_sum = 6 + 12 = 18
Therefore, result = odd_level_sum – even_level_sum = 18 – 30 = -12
Input:
Output: -12
方法：给定的问题可以通过使用水平顺序遍历来解决。请按照以下步骤解决给定的问题。
- 创建队列q ，用于存储节点。另外，创建两个变量odd_level_sum和even_level_sum分别存储树的奇数和偶数级别的叶子节点的总和。另一个变量级别跟踪遍历中的级别。
- 从根节点开始进行层序遍历，将每个节点存入队列，同时检查当前节点是否为叶子节点。如果它是叶节点，则通过检查级别将其值添加到odd_level_sum或even_level_sum中。
- 完成上述步骤后，打印odd_level_sum和even_level_sum之间的差异。
下面是上述方法的实现：
C++
// C++ program for above approach
#include
using namespace std;
// A tree node structure
struct Node {
int data;
Node *left, *right;
};
// Utility function to create
// a new Binary Tree node
Node* newNode(int data)
{
Node* temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// Function to print the difference
void printDifference(Node* root)
{
if (root == NULL) {
cout << "No nodes present\n";
return;
}
int odd_level_sum = 0,
even_level_sum = 0,
level = 1;
// queue to hold tree node with level
queue q;
// Root node is at level 1 so level=1
q.push(root);
// Do level Order Traversal of tree
while (!q.empty()) {
int n = q.size();
while (n--) {
Node* temp = q.front();
q.pop();
if (temp->left == NULL
&& temp->right == NULL) {
if (level & 1) {
odd_level_sum += temp->data;
}
else {
even_level_sum += temp->data;
}
continue;
}
if (temp->left) {
q.push(temp->left);
}
if (temp->right) {
q.push(temp->right);
}
}
level++;
}
cout << odd_level_sum - even_level_sum;
}
// Driver Code
int main()
{
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->right->left = newNode(6);
root->right->right = newNode(7);
root->left->left->right = newNode(8);
root->left->right->right = newNode(9);
root->right->right->left = newNode(10);
root->right->right->right = newNode(11);
root->left->left->right->right = newNode(12);
printDifference(root);
return 0;
} Java
// Java program for above approach
import java.util.LinkedList;
import java.util.Queue;
class GFG {
// A tree node structure
static class Node {
int data;
Node left;
Node right;
public Node(int data) {
this.data = data;
this.left = null;
this.right = null;
}
};
// Utility function to create
// a new Binary Tree node
static Node Node(int data) {
Node temp = new Node(0);
temp.data = data;
temp.left = temp.right = null;
return temp;
}
// Function to print the difference
static void printDifference(Node root) {
if (root == null) {
System.out.println("No nodes present");
return;
}
int odd_level_sum = 0,
even_level_sum = 0,
level = 1;
// queue to hold tree node with level
Queue q = new LinkedList();
// Root node is at level 1 so level=1
q.add(root);
// Do level Order Traversal of tree
while (!q.isEmpty()) {
int n = q.size();
while (n-- > 0) {
Node temp = q.peek();
q.remove();
if (temp.left == null
&& temp.right == null) {
if ((level & 1) > 0) {
odd_level_sum += temp.data;
} else {
even_level_sum += temp.data;
}
continue;
}
if (temp.left != null) {
q.add(temp.left);
}
if (temp.right != null) {
q.add(temp.right);
}
}
level++;
}
System.out.println(odd_level_sum - even_level_sum);
}
// Driver Code
public static void main(String args[]) {
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
root.left.left.right = new Node(8);
root.left.right.right = new Node(9);
root.right.right.left = new Node(10);
root.right.right.right = new Node(11);
root.left.left.right.right = new Node(12);
printDifference(root);
}
}
// This code is contributed by saurabh_jaiswal. 输出
-12时间复杂度： O(N)
空间复杂度： O(N)