Reverse order level traversal of a binary tree

Author: mandliya

README.md

@@ -6,8 +6,8 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 137 |
-| Current Streak | 1 days |
+| Total Problems | 138 |
+| Current Streak | 2 days |
 | Longest Streak | 91 ( August 17, 2015 - November 15, 2015 ) |
 
 </center>
@@ -120,6 +120,7 @@ Include contains single header implementation of data structures and some algori
 | Given a binary tree and key, node with key exists in tree. Find all the ancestors of the node with key, ancestor here are the nodes which are in straight path from node to root.| [node_ancestors_in_root_path.cpp](tree_problems/node_ancestors_in_root_path.cpp)|
 | Given a binary tree and key, return the level of the node with key. Root is at level 1, and if node with key does not exists in tree, return 0| [level_of_node.cpp](tree_problems/level_of_node.cpp)|
 | Given a binary tree, find all the paths from root to nodes, whose sum is k. | [k_sum_paths.cpp](tree_problems/k_sum_paths.cpp)|
+| Given a binary tree, print its nodes level by level in reverse order. i.e. all nodes present at last level should be printed first followed by nodes of second-last level and so on.. All nodes for any level should be printed from left to right. | [reverseLevelOrderTraversal.cpp](tree_problems/reverseLevelOrderTraversal.cpp) |
 
 ### String Problems
 | Problem | Solution |

sort_search_problems/find_pairs_with_sum.cpp

@@ -1,3 +1,18 @@
+/*
+ * Problem: 
+ * Given an unsorted array of integers, find a pair with given sum in it.
+ * For example,
+ * Input:
+ * arr = [8, 7, 2, 5, 3, 1]
+ * sum = 10
+ *
+ * Output: 
+ * Pair found at index 0 and 2 (8 + 2)
+ * OR
+ * Pair found at index 1 and 4 (7 + 3)
+ */
+
+
 #include <bits/stdc++.h>
 
 

tree_problems/reverseLevelOrderTraversal.cpp

@@ -0,0 +1,91 @@
+/*
+ * Reverse Level Order Traversal of Binary Tree
+ * Given a binary tree, print its nodes level by level in reverse order.
+ * i.e. all nodes present at last level should be printed first followed
+ * by nodes of second-last level and so on..
+ * All nodes for any level should be printed from left to right.
+ *
+ *               1
+ *             /   \
+ *            2     3
+ *           / \   / \
+ *          4  5  6   7
+ *
+ * The reverse level order traversal of the tree is : 
+ * 4, 5, 6, 7, 2, 3, 1 
+ */
+
+
+
+
+#include <bits/stdc++.h>
+
+
+struct TreeNode
+{
+    int data;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode (int d)
+        : data {d}
+        , left {nullptr}
+        , right {nullptr} {}
+};
+
+void printReverseLevelOrder(TreeNode* root)
+{
+    if (!root)
+    {
+        return;
+    }
+
+    // Idea is to do a level order traversal and then 
+    // push the nodes in a stack, so we can print in 
+    // reverse order.
+    //
+    std::queue<TreeNode*> nodeQueue;
+    std::stack<TreeNode*> nodeStack;
+    nodeQueue.push(root);
+    while (!nodeQueue.empty())
+    {
+        TreeNode* curr = nodeQueue.front();
+        nodeQueue.pop();
+        nodeStack.push(curr);
+
+        // We will push right node first, as we want to print
+        // reverse level order traversal.
+        //
+        if (curr->right)
+        {
+            nodeQueue.push(curr->right);
+        }
+
+        if (curr->left)
+        {
+            nodeQueue.push(curr->left);
+        }
+    }
+
+    std::cout << "Reverse level order traversal:";
+    while (!nodeStack.empty())
+    {
+        TreeNode* curr = nodeStack.top();
+        std::cout << curr->data << " ";
+        nodeStack.pop();
+    }
+    std::cout << std::endl;
+}
+
+
+int main()
+{
+    TreeNode* root = new TreeNode(1);
+    root->left = new TreeNode(2);
+    root->right = new TreeNode(3);
+    root->left->left = new TreeNode(4);
+    root->left->right = new TreeNode(5);
+    root->right->left = new TreeNode(6);
+    root->right->right = new TreeNode(7);
+    printReverseLevelOrder(root);
+    return 0;
+}