给定一棵二叉树，任务是在树的层级遍历中打印奇数级的偶数定位节点。根被认为是在级别0处，而任何级别的最左边的节点都被认为是在位置0处的节点。
例子：
Input:
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
/ \
10 11
Output: 2 8
Input:
2
/ \
4 15
/ /
45 17
Output: 4
先决条件–均匀定位的元素处于均匀级别
方法：要逐级打印节点，请使用级顺序遍历。这个想法是基于逐行遍历打印级别顺序的。为此，逐级遍历节点，并在每级之后切换奇数级标志。同样，将每个级别的第一个节点标记为偶数位置，并在每次处理下一个节点后将其切换。
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
using namespace std;
struct Node {
int data;
Node *left, *right;
};
// Iterative method to do level order
// traversal line by line
void printOddLevelEvenNodes(Node* root)
{
// Base Case
if (root == NULL)
return;
// Create an empty queue for level
// order traversal
queue q;
// Enqueue root and initialize level as even
q.push(root);
bool evenLevel = true;
while (1) {
// nodeCount (queue size) indicates
// number of nodes in the current level
int nodeCount = q.size();
if (nodeCount == 0)
break;
// Mark 1st node as even positioned
bool evenNodePosition = true;
// Dequeue all the nodes of current level
// and Enqueue all the nodes of next level
while (nodeCount > 0) {
Node* node = q.front();
// Print only even positioned
// nodes of even levels
if (!evenLevel && evenNodePosition)
cout << node->data << " ";
q.pop();
if (node->left != NULL)
q.push(node->left);
if (node->right != NULL)
q.push(node->right);
nodeCount--;
// Switch the even position flag
evenNodePosition = !evenNodePosition;
}
// Switch the even level flag
evenLevel = !evenLevel;
}
}
// Utility method to create a node
struct Node* newNode(int data)
{
struct Node* node = new Node;
node->data = data;
node->left = node->right = NULL;
return (node);
}
// Driver code
int main()
{
struct 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->right->left = newNode(8);
root->left->right->right = newNode(9);
root->left->right->left->left = newNode(10);
root->left->right->right->right = newNode(11);
printOddLevelEvenNodes(root);
return 0;
} Java
// Java implementation of the approach
import java.util.*;
class GFG
{
static class Node
{
int data;
Node left, right;
};
// Iterative method to do level order
// traversal line by line
static void printOddLevelEvenNodes(Node root)
{
// Base Case
if (root == null)
return;
// Create an empty queue for level
// order traversal
Queue q = new LinkedList<>();
// Enqueue root and initialize level as even
q.add(root);
boolean evenLevel = true;
while (true)
{
// nodeCount (queue size) indicates
// number of nodes in the current level
int nodeCount = q.size();
if (nodeCount == 0)
break;
// Mark 1st node as even positioned
boolean evenNodePosition = true;
// Dequeue all the nodes of current level
// and Enqueue all the nodes of next level
while (nodeCount > 0)
{
Node node = q.peek();
// Print only even positioned
// nodes of even levels
if (!evenLevel && evenNodePosition)
System.out.print(node.data + " ");
q.remove();
if (node.left != null)
q.add(node.left);
if (node.right != null)
q.add(node.right);
nodeCount--;
// Switch the even position flag
evenNodePosition = !evenNodePosition;
}
// Switch the even level flag
evenLevel = !evenLevel;
}
}
// Utility method to create a node
static Node newNode(int data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null;
return (node);
}
// Driver code
public static void main(String[] args)
{
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.right.left = newNode(8);
root.left.right.right = newNode(9);
root.left.right.left.left = newNode(10);
root.left.right.right.right = newNode(11);
printOddLevelEvenNodes(root);
}
}
// This code is contributed by 29AjayKumar Python3
# Python3 implementation of the approach
# Utility method to create a node
class newNode:
# Construct to create a new node
def __init__(self, key):
self.data = key
self.left = None
self.right = None
# Iterative method to do level order
# traversal line by line
def printOddLevelEvenNodes(root):
# Base Case
if (root == None):
return
# Create an empty queue for level
# order traversal
q =[]
# Enqueue root and initialize level as even
q.append(root)
evenLevel = True
while (1):
# nodeCount (queue size) indicates
# number of nodes in the current level
nodeCount = len(q)
if (nodeCount == 0):
break
# Mark 1st node as even positioned
evenNodePosition = True
# Dequeue all the nodes of current level
# and Enqueue all the nodes of next level
while (nodeCount > 0):
node = q[0]
# Pronly even positioned
# nodes of even levels
if not evenLevel and evenNodePosition:
print(node.data, end =" ")
q.pop(0)
if (node.left != None):
q.append(node.left)
if (node.right != None):
q.append(node.right)
nodeCount-= 1
# Switch the even position flag
evenNodePosition = not evenNodePosition
# Switch the even level flag
evenLevel = not evenLevel
# Driver code
if __name__ == '__main__':
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.right.left = newNode(8)
root.left.right.right = newNode(9)
root.left.right.left.left = newNode(10)
root.left.right.right.right = newNode(11)
printOddLevelEvenNodes(root)C#
// C# implementation of the approach
using System;
using System.Collections.Generic;
class GFG
{
class Node
{
public int data;
public Node left, right;
};
// Iterative method to do level order
// traversal line by line
static void printOddLevelEvenNodes(Node root)
{
// Base Case
if (root == null)
return;
// Create an empty queue for level
// order traversal
Queue q = new Queue();
// Enqueue root and initialize level as even
q.Enqueue(root);
bool evenLevel = true;
while (true)
{
// nodeCount (queue size) indicates
// number of nodes in the current level
int nodeCount = q.Count;
if (nodeCount == 0)
break;
// Mark 1st node as even positioned
bool evenNodePosition = true;
// Dequeue all the nodes of current level
// and Enqueue all the nodes of next level
while (nodeCount > 0)
{
Node node = q.Peek();
// Print only even positioned
// nodes of even levels
if (!evenLevel && evenNodePosition)
Console.Write(node.data + " ");
q.Dequeue();
if (node.left != null)
q.Enqueue(node.left);
if (node.right != null)
q.Enqueue(node.right);
nodeCount--;
// Switch the even position flag
evenNodePosition = !evenNodePosition;
}
// Switch the even level flag
evenLevel = !evenLevel;
}
}
// Utility method to create a node
static Node newNode(int data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null;
return (node);
}
// Driver code
public static void Main(String[] args)
{
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.right.left = newNode(8);
root.left.right.right = newNode(9);
root.left.right.left.left = newNode(10);
root.left.right.right.right = newNode(11);
printOddLevelEvenNodes(root);
}
}
// This code is contributed by 29AjayKumar 输出：
2 8