二叉树 奇偶行输出方向相反_二叉树中的奇偶级差

二叉树 奇偶行输出方向相反

Problem statement:

问题陈述：

Given a Binary Tree, write a function getLevelDiff which returns the difference between the sum of nodes at odd level and the sum of nodes at even level. The function getLevelDiff takes only one argument, i.e., the root of the binary tree.

给定一个二叉树，编写一个函数getLevelDiff ，该函数返回奇数级的节点总数与偶数级的节点总数之差 。 函数getLevelDiff仅接受一个参数，即二叉树的根。

Solution

解

Example:

例：

 3
/ \
4  6

for, the above tree the odd level sum is 3 (root itself) and even level sum is 10 (leaf nodes here) thus the difference is 3-10=-7

因为上面的树的奇数级总和是3(根本身)，偶数级总和是10(此处是叶节点)，所以差是3-10 = -7

Algorithm:

算法：

We solve the problem with help of level order traversal.

我们借助级别顺序遍历来解决该问题。

Function getLevelDiff( Node* root)

函数getLevelDiff(Node * root)

1. Initialize two flags, one for even level & other for odd levels.

1.初始化两个标志，一个标志为偶数级，另一个标志为奇数级。

flago=flag for odd levels
flage=flag for even levels
flago=1,flag e=0

falgo is initialized to 1 because we are starting with root which is considered to be odd level.

falgo初始化为1，因为我们从被认为是奇数级的root开始。

2. Initialize two variables, one to store sum of all odd levels & other to store sum of all even levels.

2.初始化两个变量，一个变量存储所有奇数级的和，另一个变量存储所有偶数级的和。

sumo = variable to store sums of all nodes at odd levels
sume = variable to store sums of all nodes at even levels
sumo = 0, sume =0 (initialized)

3. Do a level order traversal being conscious about current level whether odd or even. We can do this using the flags. When flage=1 and flago=0 we are at an even level. So we add the traversed node values with sume. When flago=1 and flage=0 we are at an odd level. So we add the traversed node values with sumo.

3.进行水平顺序遍历时要注意当前水平(奇数或偶数)。 我们可以使用标志来做到这一点。 当flage = 1和flago = 0时，我们处于同一水平。 因此，我们将遍历的节点值与sume相加。 当flago = 1且flage = 0时，我们处于奇数水平。 因此，我们将遍历的节点值与sumo相加。

We every time push NULL at end of each level & swap values between the flags at end of each level. For example when root is processed (odd level) & we encounter a NULL, we change flage from 0 to 1, flago from 1 to 0 as we are gong to process a even level now
Finally we achieve both the sums.

我们每次在每个级别末尾推送NULL并在每个级别末尾的标志之间交换值。 例如，当根被处理(奇数级)并且遇到NULL时，我们将flage从0更改为1，将flago从1更改为0，因为我们现在正在处理偶数级
最后，我们实现了两个总和。

4. Return sumo-sume

4.返回相加

Pseudo code:

伪代码：

//initialization
flage=0,flago=1;
queue
   
   
    
     q; //queue for level order traversal
sume=0,sumo=0;
Node* temp;

EnQueue(q,root);
EnQueue(q,NULL);

While (q is not empty){
	temp =DeQueue(q);
	IF(temp==NULL){
		IF(q is not empty){
			EnQueue(q,NULL);
		}
		//change flags
		IF(flago){
			flage=1;
			flago=0;
		}
		ELSE{
			flago=1;
			flage=0;
		}
	}
	ELSE{
		IF(flage) //at even level
			sume+=temp->data;
		IF(flago) //at odd level
			sumo+=temp->data;

		IF(temp->left)
			EnQueue(q, temp->left);
		IF(temp->right)
			EnQueue(q, temp->right);
	}
}
return sumo-sume;

   
   

C++ implementation

C ++实现

#include <bits/stdc++.h>
using namespace std;

class Node{
	public:             
	int data;           //value
	Node *left;    //pointer to left child
	Node *right;   //pointer to right child
};

// creating new node
Node* newnode(int data)  
{ 
	Node* node = (Node*)malloc(sizeof(Node)); 
	node->data = data; 
	node->left = NULL; 
	node->right = NULL; 

	return(node); 
}


int getLevelDiff(Node *root)
{
	//Your code here
	int flage=0,flago=1;
	queue<Node*> q;
	int sume=0,sumo=0;
	Node* temp;

	q.push(root);
	q.push(NULL);

	while(!q.empty()){
		temp=q.front();
		q.pop();
		
		if(temp==NULL){
			if(!q.empty()){
				q.push(NULL);
			}
			if(flago){
				flage=1;
				flago=0;
			}
			else{
				flago=1;
				flage=0;
			}
		}
		else{
			if(flage)
				sume+=temp->data;
			if(flago)
				sumo+=temp->data;

			if(temp->left)
				q.push(temp->left);
			if(temp->right)
				q.push(temp->right);
		}
	}
	return sumo-sume;
}

int main(){
	cout<<"tree is built as per example\n";
	
	Node *root=newnode(1); 
	root->left= newnode(2); 
	root->right= newnode(2); 
	root->right->right=newnode(3);
	root->right->left=newnode(4);
	root->left->left=newnode(3); 
	root->left->right=newnode(4);
	
	cout<<"difference between odd & even levels: "<<getLevelDiff(root)<<endl;
	
	return 0;
}

Output

输出量

tree is built as per example
difference between odd & even level: 11

Example with explanation

带说明的例子

Let the tree be,
      1
    /   \
   2     2
  / \   / \
 3   4 4   3

So the odd levels’ sum is = 1+14=15
Even level’s sum is = 4
So the difference is: 11
---------------------------------------------------------

At level 1:     
It's odd level                                                                      
1 is processed                                                                           
current odd level sum:1
---------------------------------------------------------

At level 2:             
It’s even level                                                          
2 is processed                                                                           
current even level sum:2                                                             
2 is processed                                                                           
current even level sum:4                                                             
---------------------------------------------------------

At level 3:                                                                      
It’s odd level
3 is processed                                                                           
current odd level sum:4                                                              
4 is processed                                                                           
current odd level sum:8                                                              
4 is processed                                                                           
current odd level sum:12                                                              
3 is processed
current odd level sum:15
---------------------------------------------------------

Traversal ends
Finally,
Odd level sum=15
Even level sum=4
Difference =15-4=11

翻译自: https://www.includehelp.com/icp/odd-even-level-difference-in-a-binary-tree.aspx

二叉树 奇偶行输出方向相反