Judge if the leaves of a tree are in the same level or not:
1. Iteration Version:
- Description:
If the tree is null,return true.
Else,using the level order traversal to examine every levels of the tree and judge according to wheather all the leaves are at the same level.
- Pseudocode:
Algoritm: SameLevel(node* root)
Input:a pointer of node pointing to a root of a tree.
Output:a bool which is true when all the leaves(if exsits) are at the same level and false vice versa.
queue<int> tem;
if root == NULL then
return true;
tem.push(root);
while tem.size() != 0 do
flag <- -1; //-1 for uninitialized,0 for non-leaf nodes before,1 for leaves before
size <- tem.size(); //record the node number of this level
for i <- 0 to i < size do
NodeTem <- tem.front();
tem.pop();
if NodeTem.leftc == NULL && Node.right == NULL then
if flag == -1 then
flag <- 1;
else if flag == 0 then
return false;
else
if flag == -1 then
flag <- 0;
else if flag == 1 then
return false;
//push the next level into the queue
if nodeTem.leftc != NULL then
tem.push(nodeTem.leftc);
if nodeTem.rightc != NULL then
tem.push(nodeTem.rightc);
return true;- Analysis:
time : O(n)
space : O(n)
- Thoughts:
1. the key of this algorithm is how can we process the same level of a tree and how we judge the same level nodes.
2. i have wrote the pseudocode and it did help me figure out how i'll write the code but it's hard for me to make sure the correctness of the pseudocode and i still debug my code as if the pseudocode is somehow pointless.how can i make the best of the pseudocode?
3. this is a rather explicit and strightforward method basicall just reinterpret the definition.
2. Recursion Version:
Description:
Examine every node of the tree :
if it has no children,then continue;
if it has one child,then examine the child;
if it has two children,then examine if the height of the two children is the same and then seperately examine the two children;
until all the nodes are examined can we reach a conclusion.
- Pseudocode:
Algoritm: SameLevel(node* root)
Input:a pointer of node pointing to a root of a (sub)tree.
Output:a bool which is true when all the leaves(if exsits) are at the same level and false vice versa.
int height(node* root);//return the height of the tree
if NodeTem.leftc == NULL && Node.rightc == NULL then
return true
else if NodeTem.leftc != NULL && NodeTem.rightc == NULL then
if SameLevel(NodeTem.leftc) then
return true;
else
return false;
else if NodeTem.rightc != NULL && NodeTem.leftc == NULL then
if SameLevel(NodeTem.rightc) then
return true;
else
return false;
else
if height(NodeTem.rightc) == height(NodeTem.leftc) && SameLevel(NodeTem.rightc) && SameLevel(NodeTem.leftc)
return true;
else
return false;