Approach: Solved using hash table, you can even solve this using 2 pointer approach where you'd have to sort the array, but then you won't be able to return index.

1. Solved using 3 for loops: Time complexity O(n^3), Leetcode time limit exceeded.
2. Solved using Recursion: Leetcode time limit exceeded.
3. Solved using 2 pointers and a for loop: Time Complexity O(n^2), Leetcode accepted.

Approach: 2 Pointers to keep track of left and right poles.

Approach: O(n) approach, just keep track of lowest on left and compare with current price.

Approach: We can add 2 integers without using any arithmetic operator by using half adder.

We need XOR for sum and AND for carry.
This is the truth table for it.

Approach: Used both dfs and bfs to copy the graph. Leetcode accepted.

Approach: Used BFS topological sort. Understood the approach from this article.
The following pseudo code helped.

            L = Empty list that will contain the sorted elements 

            S = Set of all nodes with no incoming edge 

            

              While S is non-empty do: 

                  remove a node n from S 

                  add n to tail of L 

                  for each node m with an edge e from n to m do 

                      remove edge e from the graph 

                      if m has no other incoming edges then 

                          insert m into S 

              

              if graph has edges then 

                  return error   (graph has at least one cycle) 

              else 

                  return L   (a topologically sorted order) 

          

Approach: Variation of island problem, solved using DFS. Can be solved using BFS

Approach: Solved using DFS

Approach: Used 3 pointer approach

Approach: Used rabbit and tortoise method, where we move rabbit by 2 positions and tortoise by 1. If at any given point the 2 meet then we got a cycle. You can also solve this porblem by having a hash table and making note of all the nodes seen so far.

Approach: Simple O(n) merging, by traversing both lists at the same time.

Approach: Use heap sort to merge k lists.

Approach: Use rabbit and tortoise method. Move rabbit n spaces, then move tortoise along with rabbit unitl rabbit reaches end of the list.

Approach: Detached list in the middle using rabbit and tortoise method. Put the second list in stack and detached it's nodes. Traversed the first list and added the stack nodes in between. Total time O(n), space O(n/2)

Approach: Set the row and col of the cell with zero to value "x". Then in second pass, change all the cells with "x" to zero. This ensures we use no extra space and do it in O(n) time.

Approach: Had to see this idea from leetcode solutions.
First write a function that first prints the spiral of rows and cols, then just reduce the bounds and do the same.
Don't forget the mark the cells visited to avoid duplicates.

Approach: First swap the elements under red triangle with the green triangle.

Then flip the matrix upside down.

Approach: Similar to island problem, dfs and backtracking for visited cells.
Make sure to check if all the letters in the word are present on the board before proceeding to find the word.

Approach: We use sliding window for this one. Use hash table to keep track of the letters in the window.

Approach: Following formula used
(length of substring - number of times of the maximum occurring character in the substring) <= k

Approach: Used hash table.

Approach: Sort the strings and store them in hash table.

Approach: done using simple (any)-order traversal.

Approach: do any 2 traversals and compare them. I did in-order and post-order.

Thoughts: My initial thought was to do level order traversal and then flip the nodes. But this approach was unnecessarily complicated.
Approach: Perform a post-order traversal and flip left and right child of each node. What this creates is that even if you flip 1 node at a time, since you'll be flipping their parent too, all the nodes get flipped automatically.

Approach: It's pretty similar to finding height of a tree. The only catch is what to return.

Approach: Used a modified iterative BFS

Approach: Use preorder to serialize it using comma as delimiter.
Then use similar method we use to find height of tree to first add left child of sub tree and then add right child of sub tree, all while traversing the array.

Thoughts: Initially I thought of using tries to do this, but it can create problems if all nodes of the tree have same value.
My next thought was to do inOrder and preOrder traversal and then build the tree, but I was plagued by the same above problem, what if all tree nodes have same value.
Then I thought about level order traversal but use delimiter for null nodes, this will waste a LOT of space (what if the tree is skewed), but I will end up with correct answer.

• Too much space with level order: This exceeded leetcode space limit.

Approach: Recursive function similar to inorder traversal that checks if 2 sub trees are same or not. Another function that checks if the current node in the larger tree is same as the root of sub tree, then it calls the previous function to check if the subtrees are same or not.

Approach: Do an inorder traversal of the BST.
Then validate if the traversal is in ascending order or not.

Approach: User inorder traversal to find the kth smallest element.

Approach: First search for the nodes in left sub tree, and right sub tree. If found return the root.
Don't forget to trickle the answer upwards if nothing is found. Approach similar to postOrder traversal of the tree.

Thoughts: You can also use this approach to serialise and de-serialise an n-ary tree.

Approach: Use trie for this.

Approach: First build a hash table with key: element, value: frequency.
Then Create a heap and add all elements from the hash to the heap in form of tuple (python thing).
Remove the top k elements from the heap.

Approach: Keep 2 heaps, max heap to hold all elements less than median and min heap to hold elements greater than the median.
Finding median: which ever heap has more elements, the top element of that heap is the median.
If both heaps have same elements, then median is (minHeapTop+maxHeapTop) / 2
If at any point one heap has 2 elements more than other heap, pop an element from that heap and add it to another heap.