* [add_followup - adding list such that 1's digit is at tail( follow up part of question) * @param list1 * @param list2 * @return list3 represent

* [add_iterative iterative approach to add two given lists] * @param list1 * @param list2 * @return list3 */

* [add_recursive - recursive addititon of two lists * @param list1 * @param list2 * @param carry * @return list3 */

We travel down to see where is the divergent point such that two query nodes are NOT in the same branch*/

A recursive function used by countWays

Build a BST first, and searching for in-order successor of a given node.*/

* [deleteList - delete the entire list] * @param head - head of the list */

* [deleteNode - delete the "node" from the list] * @param node [node to be deleted] */

The crucial point is that root must come before all its children. We do it recursivley, at each level: We first compute all permutations of left s

It mainly finds the previous color on (x, y) and calls floodFillUtil()

A recursive function to replace previous color 'prevC' at '(x, y)' and all surrounding pixels of (x, y) with new color 'newC' and

Checks if path is valid and simultaneously adds position to a result vector

* Insert to the head of the list * @param head - Current head of list * @param data - new node's data */

* [intersectionPoint Returns the point of intersection of two lists] * @param head1 [ head of list 1 ] * @param head2 [ head of list 2 ] * @retur

The check is performed recursively. The min/max solution. We proceed through the tree with this approach. When we branch left, the max gets updated to

Returns true if binary tree with root as root is height-balanced */

* [isPallindromeIter1 - Iteratively determine if list is palindrome using reversing the list] * @param head [Head node of the list] * @return

* [kthToLastHelper - helper routine to find nth node for recursive approach * @param head - head of the list * @param k - the k value for fin

* kthToLastIterative - Iterative approach for finding kth to last element of list. * @param head - head of node * @param k - the k value for

* kthToLastRecursive - Recursive approach for finding kth to last element of list. * @param head - head of node * @param k - the k value for

The second method is the Solution 3 discussed in the book, where division operation is used.*/

We start with a new list. Elements bigger than the pivot element are put at the tail list and elements smaller are put at the head list*/

Function to print permutations of string This function takes three parameters: 1. String 2. Starting index of the string 3. Ending index o

* printList - Helper routine to print the list * @param head - Current head of the list. */

Wrapper over _printParenthesis()*/