This is to keep track of the topics studied or revised
--> 112. Path Sum
--> 42. Trapping Rain Water
--> 336. Palindrome Pairs (DO AGAIN)
--> 1770. Maximum Score from Performing Multiplication Operations
-->2007. Find Original Array From Doubled Array
-->1457. Pseudo-Palindromic Paths in a Binary Tree
--> 393. UTF-8 Validation
--> 948. Bag of Tokens
--> 1383. Maximum Performance of a Team REDO
--> 188. Best Time to Buy and Sell Stock IV
--> 1996. The Number of Weak Characters in the Game
--> 94. Binary Tree Inorder Traversal
--> 606. Construct String from Binary Tree
--> 814. Binary Tree Pruning
--> 987. Vertical Order Traversal of a Binary Tree (Revise)
--> 429. N-ary Tree Level Order Traversal
--> 1143. Longest Common Subsequence
--> Longest Common Substring
--> 967. Numbers With Same Consecutive Differences
--> Tree Ques Leetcode 1448. Count Good Nodes in Binary Tree
--> 637. Average of Levels in Binary Tree
--> DP KnapSack Pattern
--> DP
--> JS splice(), loops
--> Fenwick Tree
--> 307. Range Sum Query - Mutable
--> TicTacToe
--> Graph - 3 Cycle
--> Revision - Print Paths
--> Connected components
--> Number Of Islands
--> Largest Piece
--> Graph - Island (Components)
--> CODINGNINJAS String Graph DFS
--> Dijkstra Adj. Matrix Done
--> Dijkstra Algorithm started
--> Kruskal's Algorithm
--> Prims's Algorithm Started
--> Kruskal's Algorithm
--> Graph Cyclic Detection
--> Code : Get Path - DFS
--> Code : Get Path - BFS
--> Code : Is Connected ?
--> Code : All connected components
--> Maximum Square Matrix With All Zeros
--> Smallest Super-Sequence
--> Graph Started
--> Graph Implementation
--> Adjacency Matrix vs Adjacency List
--> Code : BFS Traversal
--> Code : Has Path
--> Coin Tower
--> Trie Palindrom Pair
--> Trie Auto Complete
--> Loot Houses
--> Code: Knapsack(Memoization and DP)
--> LCS
--> Code: Edit Distance
--> Code: Edit Distance(Memoization and DP)
--> Code: 0 1 Knapsack
--> Priority Queue & DP Continued
--> Code: Number of Balanced BTs Completed
--> Code: Minimum Count of Squares REVISIT
--> DP : PEP - Coin Change Permutations
--> DP : PEP - Coin Change Combination
--> Amazon Test
--> Byte Landian DP
--> Code : Minimum Cost Path
--> Priority Queue Continued
--> Code - Implace Heap sort done
--> K Largest element AL
--> K smallest Element AL
--> Check Max-Heap
--> Kth largest element
--> Trie Started
--> Trie Implementation
--> Trie Vs HashMap
--> Count Words in Trie
--> Buy the ticket
--> Pattern Matching
--> Running Median
--> Merge K sorted arrays
--> some Trie pending
--> DP - Code: Min Steps to One
--> Code: Staircase
--> Code: Number of Balanced BTs pending...
--> DP Start PriorityQueue pending
--> Fibonacci DP
--> Computer Networks Basics
--> Linux Started
--> Basics Done
--> Leetcode SQL: easy 3 Qs
--> PriorityQueue Continue
--> Code - Implace Heap sort Pending
--> Basics of SQL
--> Priority Queue Continue
--> Code : Remove Min
--> Code : Max Priority Queue
--> Priority Queue & Heap theory
--> Priority Queue Implementation
--> LeetCode :
- Middle Of A LinkedList
- Reverse a LinkedList
- Reorder a LinkedLIst
- Merge Two Sorted LinkedList
- Merge K sorted Linked list
--> HashMap Continue
--> Print Intersection
--> Extract Unique characters
--> Longest Consecutive Sequence
--> Pairs with difference K
--> Longest subset zero sum
--> LeetCode : 3. Longest Substring Without Repeating Characters
--> LeetCode : 217. Contains Duplicate
--> LeetCode : 242. Valid Anagram
--> Leetcode: addTwoNumbers LinkedList
--> HashMap Theory
--> Priority Queue
--> Binary Search Tree continue
--> Path Sum Root to Leaf DO AGAIN for O(log n) space
--> Print nodes at distance k from node
--> Pair sum in a BST
--> Check cousins DO AGAIN
--> Longest Leaf to root path
--> Remove leaf nodes in Tree
--> HashMap Start
--> Maximum Frequency Number
--> Pair Sum to 0
-->
--> Binary Search Tree continue
--> Largest BST
--> Replace with Sum of greater nodes Do dry run
--> basics
--> Binary Search Tree continue
--> Find path in BST
--> Create & Insert Duplicate Node
--> LCA of Binary Tree
--> LCA of BST
--> Pair Sum Binary Tree
--> Path Sum Root to Leaf
--> Binary Search Tree continue
--> Print nodes at distance k from node PENDING
--> Check if a Binary Tree is BST 3 methods used 1st have to do other 2
--> Code: Construct BST From Sorted Array
--> Code: BST to Sorted LL NOT EFFICIENT pending class method
--> Binary Tree continue
--> Diameter Of Binary Tree Using class
--> Mirror a Binary Tree
--> Preorder Binary Tree
--> Postorder Binary Tree
--> Code: Search Node in BST
--> Code: Print Elements in Range
--> Code: Construct Tree from Preorder and Inorder
--> Code: Construct Tree from Postorder and Inorder
--> Create & Insert Duplicate Node to left
--> Minimum and Maximum in the Binary Tree
--> Level order traversal in BT
--> Path Sum Root to Leaf
--> Added contact us to HTML CSS RESUME page
--> Making work experience section pending
--> Tree and Binary Tree continue
--> Sum of nodes
--> find node
--> print levelwise
--> Nodes Greater Than X
--> Height Of Binary Tree
--> Replace Node With Depth
--> Nodes without sibling
--> Diameter Of Binary Tree O(n^2)
--> Tree continue
--> Node having sum of children and node is max using Class
--> Structurally identical using Queue Pending Recursion
--> Next larger element using Queue and Stack Pending Recursion
--> Second Largest Element In Tree
--> Replace node with depth
--> Got PR merged at PublicLabs
--> Tree
--> Tree implementation using ArrayList
--> Tree takeInput() recursively
--> print() recursively
--> print() levelwise using Queue
--> takeInput() levelwise using Queue
--> Count total nodes in a tree
--> Height of the tree
--> Depth theory can be done using k as argument in recursion
--> Count Leaf nodes
--> Traversals - LevelWise (Queue using breakNode)
--> Traversals - preOrder
--> Traversals - postOrder
--> Number of nodes greater than x
--> Target Sum Subarray
--> N-Queens
--> K-Knights
--> Redundant Brackets Stack
--> Balanced Brackets Stack
--> Next Greater Element To The Right
--> Revising Recursion
--> Get Maze Path
--> Get Maze Path with Jumps
--> Print Subsequence
--> print kpc
--> print stair path
--> print maze path and with jump
--> print permutations
--> Print Encodings '0' case
--> Flood Fill using -1 as visited
--> Flood Fill using Visited Boolean to back track
--> LeetCode 1710. Maximum Units on a Truck using recursion
--> Stack using 2 Queue
--> Reverse Queue recursively
--> Reverse the First K Elements in the Queue O(n^2) & O(n)
--> Double Ended Queue Using LinkedList TODO using array
--> Next Number (increment a num in LL e.g. 9 -> 9 -> 9 to 1->0->0->0)
--> Delete Alternate Nodes LL easy
--> Started building Resume WebPage
--> Added navbar, Header Section, About Section
--> Minimum bracket Reversal (revisit)
--> Queue -- Implementation using Array
--> Queue -- Implementation usind Linked List
--> Flex
--> Stock Span using hint
--> kReverse Recursively DoubleNode class
--> Bubble Sort on LL Iteratively. (PRACTISE)
--> We can solve it recursively refer to row col pattern approach
--> Stack -- Implementation using array Exceptions
--> Stack -- Implementation using Singly Linked List O(1) Pop and Push
--> Balanced Parenthesis
--> Check redundant brackets
--> Stock Span (continue)...
--> Display inline, block, inline-block
--> Margin
--> Padding
--> Basic Blog edits
--> Position Ficed need top argument
--> Even after Odd LinkedList O(N) space O(N)
--> Revision of LL
--> Delete every N nodes
--> Swap two Nodes of LL
--> kReverse trying pending...
--> Form
--> Reported a bug to security team while exploring the website
--> Made Login and Registeration form using sandbox
--> Basics of CSS
--> Google Cloud Labs
--> Palindrome LinkedList (done) find mid point, can be done using slow fast point approach.
then reversed the LL and compared till head2 not null
--> Code : Midpoint of Linked list (return mid node)
--> Merge two sorted LinkedList O(1) Space
--> MergeSort in LinkedList
--> Deleting a node (recursively)
--> Reverse LL (Recursive) O(n^2) O(n) by doubleNode and by storing next node as tail
--> Circular Singly LL
--> Circular Doubly LL
--> LinkedList Collection framework
--> Basics of HTML
--> Schedule Table (rowspan colspan)
--> Learned OOPs concepts like abstract classes -- need to be implemented in subclass unless specified abstract
--> Interface -- contains all abstract methods
--> Generic Classes ArrayList T representing generic
--> Started with LinkedList
--> Implementation of LL self by creating Generic Node class
--> Basic methods insert delete find ith
--> Find a node in LinkedList
--> Append last N to First
--> Eliminate Duplicates from LinkedList
--> Print Reversed Linked List
--> Palindrome LinkedList -- (?) pending...