A stack can be implemented using two queues. Let stack to be implemented be ‘x’ and queues used to implement be ‘a’ and ‘b’.

Method 1 (By push operation)
This method makes sure that the newly entered element is always at the front of ‘a’, so that pop operation just dequeues from ‘a’. ‘b’ is used to put every new element at front of ‘b’.

The correct solution is 'option 1'.

Key Points

  Algo Preorder(tree root)

  {

1. Visit the root node.
2. Traverse the left subtree ( call Algo Preorder(left-subtree) ).
3. Traverse the right subtree ( call Algo Preorder(right-subtree) ).

  }

• Start with a root node 'A' move towards it's left subtree i.e 'B'. And again the node 'B' becomes the root node. Recursively calling by the above function prints the pre-order of the above Tree. 

Thus, the correct answer is: A B D F E C G I H J K L

Additional Information

• To build a copy of the tree, a preorder traverse is used. Preorder traversal is often used to get the prefix on an expression tree.
•  Here, some tree traversal techniques and flow.
• In-order     -  F D B E A I G C J H L K
• Pre-order  -  A B D F E C G I H J K L
• Post-order - F D E B I G J L K H C A
• Converse Inorder - K L H J C G I A E B D F
• Converse Preorder- A C H K L J G I B E D F
• Converse  Postorder- L K J H I G C E F D B A

A stack can be implemented using two queues. Let stack to be implemented be ‘x’ and queues used to implement be ‘a’ and ‘b’.

Method 1 (By push operation)
This method makes sure that the newly entered element is always at the front of ‘a’, so that pop operation just dequeues from ‘a’. ‘b’ is used to put every new element at front of ‘b’.

Consider x = 10 and y = 25

CASE1:

If (y <= 0) return x;                           // 25<=0 (false)

                return function (y, x%y);            return function(25, 10)

CASE 2:

x = 25, y= 10

If (y <= 0) return x;                          // 10<=0 (False)

                return function (y, x%y);        // return function (10, 5)

CASE 3:

x =10, y =5

If (y <= 0) return x;                         // 5<=0 (false)

                return function (y, x%y);             //return function(5, 0)

CASE 4:

x = 5, y =0

If (y <= 0) return x;                         // condition true, return 5

                return function (y, x%y);

Output = 5

Which is greatest common divisor of 10 and 25.

So, given program computes GCD of x and y

• Queue is data structure which is First in First Out (FIFO) or Last in Last Out (LILO) which means the element which is inserted first comes out first form the queue or the elements inserted last comes out last from the queue
• Stack is data structure which is Last in First Out (LIFO) or First in Last Out (FILO) which means the element which is popped last from stack is pushed first in stack, or element which is pushed first in stack is popped last from stack

• Breadth-first search (BFS) and Depth First Search (DFS) is an algorithm for traversing or searching tree or graph data structures.
• Breadth First Search (BFS) algorithm traverses a graph in a breadthwise manner and uses a queue to remember to get the next vertex to start a search, when a dead end occurs in any iteration.
• Depth First Search (DFS) uses Stack data structure. DFS uses backtracking technique. Remember backtracking can proceed by Stack.