Convert Figma logo to code with AI

kdn251 logointerviews

Everything you need to know to get the job.

63,295
12,880
63,295
113
View on GitHub

Top Related Projects

jwasham's avatar

coding-interview-university

303,903

A complete computer science study plan to become a software engineer.

yangshun's avatar

tech-interview-handbook

116,445

💯 Curated coding interview preparation materials for busy software engineers

donnemartin's avatar

system-design-primer

268,962

Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.

trekhleb's avatar

javascript-algorithms

186,733

📝 Algorithms and data structures implemented in JavaScript with explanations and links to further readings

h5bp's avatar

Front-end-Developer-Interview-Questions

59,516

A list of helpful front-end related questions you can use to interview potential candidates, test yourself or completely ignore.

TheAlgorithms's avatar

Python

183,979

All Algorithms implemented in Python

Quick Overview

The kdn251/interviews repository is a comprehensive collection of algorithm, data structure, and interview preparation materials. It serves as a valuable resource for software engineers and computer science students preparing for technical interviews at top technology companies.

Pros

  • Extensive coverage of common interview topics and coding problems
  • Well-organized structure with clear categorization of algorithms and data structures
  • Includes solutions in multiple programming languages (primarily Java)
  • Regularly updated with new content and improvements

Cons

  • Lacks detailed explanations for some complex algorithms
  • May be overwhelming for beginners due to the vast amount of information
  • Some solutions could benefit from more comments and documentation
  • Limited coverage of system design and behavioral interview topics

Code Examples

This repository is not a code library but a collection of interview preparation materials. Therefore, code examples are not applicable in the traditional sense. However, here are a few snippets from the repository to illustrate the type of content it contains:

// Example of a binary search implementation
public int binarySearch(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return -1;
}

// Example of a linked list reversal
public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    
    while (curr != null) {
        ListNode nextTemp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = nextTemp;
    }
    
    return prev;
}

Getting Started

As this is not a code library but a collection of interview preparation materials, there's no traditional "getting started" process. However, users can begin by:

  1. Cloning the repository: git clone https://github.com/kdn251/interviews.git
  2. Browsing the README.md file for an overview of topics covered
  3. Exploring the various folders containing algorithm implementations and problem solutions
  4. Practicing coding problems and studying the provided solutions

Competitor Comparisons

jwasham logo

coding-interview-university

303,903

A complete computer science study plan to become a software engineer.

Pros of coding-interview-university

  • More comprehensive and structured learning path
  • Includes additional resources like books, videos, and practice problems
  • Covers a broader range of computer science topics

Cons of coding-interview-university

  • Can be overwhelming due to the extensive content
  • May take longer to complete compared to interviews
  • Less focused on specific interview questions and solutions

Code Comparison

interviews:

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

coding-interview-university:

def reverse(head):
    prev = None
    current = head
    while current:
        next = current.next
        current.next = prev
        prev = current
        current = next
    return prev

Both repositories provide similar implementations for reversing a linked list, with interviews using Java and coding-interview-university using Python. The algorithms are essentially the same, demonstrating that both resources cover fundamental data structures and algorithms effectively.

yangshun logo

tech-interview-handbook

116,445

💯 Curated coding interview preparation materials for busy software engineers

Pros of tech-interview-handbook

  • More comprehensive coverage of non-technical aspects (e.g., behavioral questions, resume preparation)
  • Better organized structure with clear sections for different interview stages
  • Regularly updated with recent industry trends and practices

Cons of tech-interview-handbook

  • Less focus on in-depth algorithm explanations compared to interviews
  • Fewer code examples for specific problem types
  • May be overwhelming for beginners due to the breadth of information

Code Comparison

interviews:

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

tech-interview-handbook:

function reverseLinkedList(head) {
  let prev = null;
  let curr = head;
  while (curr !== null) {
    [curr.next, prev, curr] = [prev, curr, curr.next];
  }
  return prev;
}

Both repositories provide similar implementations for reversing a linked list, but interviews uses Java while tech-interview-handbook uses JavaScript. The tech-interview-handbook example is more concise due to JavaScript's destructuring assignment.

donnemartin logo

system-design-primer

268,962

Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.

Pros of system-design-primer

  • More comprehensive coverage of system design concepts
  • Includes visual aids and diagrams for better understanding
  • Regularly updated with new content and examples

Cons of system-design-primer

  • Focuses primarily on system design, lacking coverage of coding problems
  • May be overwhelming for beginners due to its extensive content
  • Less emphasis on practical implementation details

Code Comparison

system-design-primer:

class Cache:
    def __init__(self, MAX_SIZE):
        self.MAX_SIZE = MAX_SIZE
        self.size = 0
        self.lookup = {}
        self.linked_list = LinkedList()

interviews:

public class LRUCache {
    private LinkedHashMap<Integer, Integer> map;
    private final int CAPACITY;
    public LRUCache(int capacity) {
        CAPACITY = capacity;
        map = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true) {

Both repositories provide valuable resources for technical interview preparation. system-design-primer offers a deep dive into system design concepts with visual aids, while interviews covers a broader range of topics including coding problems and algorithms. The code examples show different approaches to implementing caching mechanisms, with system-design-primer using Python and interviews using Java.

trekhleb logo

javascript-algorithms

186,733

📝 Algorithms and data structures implemented in JavaScript with explanations and links to further readings

Pros of javascript-algorithms

  • Focused specifically on JavaScript implementations
  • Includes explanations and complexity analysis for each algorithm
  • Organized into categories (e.g., math, search, sorting) for easy navigation

Cons of javascript-algorithms

  • Limited to algorithms, doesn't cover data structures as extensively
  • Lacks interview-specific tips and strategies
  • May not be as comprehensive for general computer science topics

Code Comparison

interviews (Java):

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

javascript-algorithms (JavaScript):

function reverseLinkedList(head) {
  let current = head;
  let previous = null;
  let next = null;

  while (current) {
    next = current.next;
    current.next = previous;
    previous = current;
    current = next;
  }

  return previous;
}

Both repositories provide implementations for common algorithms, but interviews offers a broader range of topics in Java, while javascript-algorithms focuses on JavaScript-specific implementations with more detailed explanations.

h5bp logo

Front-end-Developer-Interview-Questions

59,516

A list of helpful front-end related questions you can use to interview potential candidates, test yourself or completely ignore.

Pros of Front-end-Developer-Interview-Questions

  • Focuses specifically on front-end development topics
  • Regularly updated with community contributions
  • Includes translations in multiple languages

Cons of Front-end-Developer-Interview-Questions

  • Limited to front-end topics, lacking broader software engineering concepts
  • Questions are primarily theoretical, with fewer practical coding challenges
  • Less structured organization compared to interviews

Code Comparison

Front-end-Developer-Interview-Questions:

// No specific code examples provided

interviews:

public int findKthLargest(int[] nums, int k) {
    PriorityQueue<Integer> pq = new PriorityQueue<>();
    for (int val : nums) {
        pq.offer(val);
        if (pq.size() > k) pq.poll();
    }
    return pq.peek();
}

Front-end-Developer-Interview-Questions focuses on theoretical questions without code examples, while interviews provides practical coding problems with solutions in various programming languages.

TheAlgorithms logo

Python

183,979

All Algorithms implemented in Python

Pros of Python

  • Extensive collection of algorithms implemented in Python
  • Well-organized structure with algorithms categorized by type
  • Active community with frequent updates and contributions

Cons of Python

  • Focused solely on Python implementations
  • Less emphasis on interview-specific preparation
  • May lack some advanced data structures found in interviews

Code Comparison

interviews:

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

Python:

def reverse_list(head):
    prev = None
    current = head
    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    return prev

Both repositories provide implementations for reversing a linked list. interviews uses Java, while Python uses Python. The logic is similar, but the syntax differs due to language differences.

interviews focuses on interview preparation with a mix of languages and topics, while Python offers a comprehensive collection of algorithms implemented in Python. interviews may be more suitable for interview-specific practice, whereas Python serves as a broader resource for learning and understanding algorithms in Python.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Interviews

Your personal guide to Software Engineering technical interviews. Video solutions to the following interview problems with detailed explanations can be found here.

Maintainer - Kevin Naughton Jr.

Translations

Table of Contents

YouTube

The Daily Byte

Instagram

Articles

Online Judges

Live Coding Practice

Data Structures

Linked List

  • A Linked List is a linear collection of data elements, called nodes, each pointing to the next node by means of a pointer. It is a data structure consisting of a group of nodes which together represent a sequence.
  • Singly-linked list: linked list in which each node points to the next node and the last node points to null
  • Doubly-linked list: linked list in which each node has two pointers, p and n, such that p points to the previous node and n points to the next node; the last node's n pointer points to null
  • Circular-linked list: linked list in which each node points to the next node and the last node points back to the first node
  • Time Complexity:
    • Access: O(n)
    • Search: O(n)
    • Insert: O(1)
    • Remove: O(1)

Stack

  • A Stack is a collection of elements, with two principle operations: push, which adds to the collection, and pop, which removes the most recently added element
  • Last in, first out data structure (LIFO): the most recently added object is the first to be removed
  • Time Complexity:
    • Access: O(n)
    • Search: O(n)
    • Insert: O(1)
    • Remove: O(1)

Queue

  • A Queue is a collection of elements, supporting two principle operations: enqueue, which inserts an element into the queue, and dequeue, which removes an element from the queue
  • First in, first out data structure (FIFO): the oldest added object is the first to be removed
  • Time Complexity:
    • Access: O(n)
    • Search: O(n)
    • Insert: O(1)
    • Remove: O(1)

Tree

  • A Tree is an undirected, connected, acyclic graph

Binary Tree

  • A Binary Tree is a tree data structure in which each node has at most two children, which are referred to as the left child and right child
  • Full Tree: a tree in which every node has either 0 or 2 children
  • Perfect Binary Tree: a binary tree in which all interior nodes have two children and all leave have the same depth
  • Complete Tree: a binary tree in which every level except possibly the last is full and all nodes in the last level are as far left as possible

Binary Search Tree

  • A binary search tree, sometimes called BST, is a type of binary tree which maintains the property that the value in each node must be greater than or equal to any value stored in the left sub-tree, and less than or equal to any value stored in the right sub-tree
  • Time Complexity:
    • Access: O(log(n))
    • Search: O(log(n))
    • Insert: O(log(n))
    • Remove: O(log(n))
Binary Search Tree

Trie

  • A trie, sometimes called a radix or prefix tree, is a kind of search tree that is used to store a dynamic set or associative array where the keys are usually Strings. No node in the tree stores the key associated with that node; instead, its position in the tree defines the key with which it is associated. All the descendants of a node have a common prefix of the String associated with that node, and the root is associated with the empty String.

Alt text

Fenwick Tree

  • A Fenwick tree, sometimes called a binary indexed tree, is a tree in concept, but in practice is implemented as an implicit data structure using an array. Given an index in the array representing a vertex, the index of a vertex's parent or child is calculated through bitwise operations on the binary representation of its index. Each element of the array contains the pre-calculated sum of a range of values, and by combining that sum with additional ranges encountered during an upward traversal to the root, the prefix sum is calculated
  • Time Complexity:
    • Range Sum: O(log(n))
    • Update: O(log(n))

Alt text

Segment Tree

  • A Segment tree, is a tree data structure for storing intervals, or segments. It allows querying which of the stored segments contain a given point
  • Time Complexity:
    • Range Query: O(log(n))
    • Update: O(log(n))

Alt text

Heap

  • A Heap is a specialized tree based structure data structure that satisfies the heap property: if A is a parent node of B, then the key (the value) of node A is ordered with respect to the key of node B with the same ordering applying across the entire heap. A heap can be classified further as either a "max heap" or a "min heap". In a max heap, the keys of parent nodes are always greater than or equal to those of the children and the highest key is in the root node. In a min heap, the keys of parent nodes are less than or equal to those of the children and the lowest key is in the root node
  • Time Complexity:
    • Access Max / Min: O(1)
    • Insert: O(log(n))
    • Remove Max / Min: O(log(n))
Max Heap

Hashing

  • Hashing is used to map data of an arbitrary size to data of a fixed size. The values returned by a hash function are called hash values, hash codes, or simply hashes. If two keys map to the same value, a collision occurs
  • Hash Map: a hash map is a structure that can map keys to values. A hash map uses a hash function to compute an index into an array of buckets or slots, from which the desired value can be found.
  • Collision Resolution
  • Separate Chaining: in separate chaining, each bucket is independent, and contains a list of entries for each index. The time for hash map operations is the time to find the bucket (constant time), plus the time to iterate through the list
  • Open Addressing: in open addressing, when a new entry is inserted, the buckets are examined, starting with the hashed-to-slot and proceeding in some sequence, until an unoccupied slot is found. The name open addressing refers to the fact that the location of an item is not always determined by its hash value

Alt text

Graph

  • A Graph is an ordered pair of G = (V, E) comprising a set V of vertices or nodes together with a set E of edges or arcs, which are 2-element subsets of V (i.e. an edge is associated with two vertices, and that association takes the form of the unordered pair comprising those two vertices)
  • Undirected Graph: a graph in which the adjacency relation is symmetric. So if there exists an edge from node u to node v (u -> v), then it is also the case that there exists an edge from node v to node u (v -> u)
  • Directed Graph: a graph in which the adjacency relation is not symmetric. So if there exists an edge from node u to node v (u -> v), this does not imply that there exists an edge from node v to node u (v -> u)
Graph

Algorithms

Sorting

Quicksort

  • Stable: No
  • Time Complexity:
    • Best Case: O(nlog(n))
    • Worst Case: O(n^2)
    • Average Case: O(nlog(n))

Alt text

Mergesort

  • Mergesort is also a divide and conquer algorithm. It continuously divides an array into two halves, recurses on both the left subarray and right subarray and then merges the two sorted halves
  • Stable: Yes
  • Time Complexity:
    • Best Case: O(nlog(n))
    • Worst Case: O(nlog(n))
    • Average Case: O(nlog(n))

Alt text

Bucket Sort

  • Bucket Sort is a sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket is then sorted individually, either using a different sorting algorithm, or by recursively applying the bucket sorting algorithm
  • Time Complexity:
    • Best Case: Ω(n + k)
    • Worst Case: O(n^2)
    • Average Case:Θ(n + k)

Alt text

Radix Sort

  • Radix Sort is a sorting algorithm that like bucket sort, distributes elements of an array into a number of buckets. However, radix sort differs from bucket sort by 're-bucketing' the array after the initial pass as opposed to sorting each bucket and merging
  • Time Complexity:
    • Best Case: Ω(nk)
    • Worst Case: O(nk)
    • Average Case: Θ(nk)

Graph Algorithms

Depth First Search

  • Depth First Search is a graph traversal algorithm which explores as far as possible along each branch before backtracking
  • Time Complexity: O(|V| + |E|)

Alt text

Breadth First Search

  • Breadth First Search is a graph traversal algorithm which explores the neighbor nodes first, before moving to the next level neighbors
  • Time Complexity: O(|V| + |E|)

Alt text

Topological Sort

  • Topological Sort is the linear ordering of a directed graph's nodes such that for every edge from node u to node v, u comes before v in the ordering
  • Time Complexity: O(|V| + |E|)

Dijkstra's Algorithm

  • Dijkstra's Algorithm is an algorithm for finding the shortest path between nodes in a graph
  • Time Complexity: O(|V|^2)

Alt text

Bellman-Ford Algorithm

  • Bellman-Ford Algorithm is an algorithm that computes the shortest paths from a single source node to all other nodes in a weighted graph
  • Although it is slower than Dijkstra's, it is more versatile, as it is capable of handling graphs in which some of the edge weights are negative numbers
  • Time Complexity:
    • Best Case: O(|E|)
    • Worst Case: O(|V||E|)

Alt text

Floyd-Warshall Algorithm

  • Floyd-Warshall Algorithm is an algorithm for finding the shortest paths in a weighted graph with positive or negative edge weights, but no negative cycles
  • A single execution of the algorithm will find the lengths (summed weights) of the shortest paths between all pairs of nodes
  • Time Complexity:
    • Best Case: O(|V|^3)
    • Worst Case: O(|V|^3)
    • Average Case: O(|V|^3)

Prim's Algorithm

  • Prim's Algorithm is a greedy algorithm that finds a minimum spanning tree for a weighted undirected graph. In other words, Prim's find a subset of edges that forms a tree that includes every node in the graph
  • Time Complexity: O(|V|^2)

Alt text

Kruskal's Algorithm

  • Kruskal's Algorithm is also a greedy algorithm that finds a minimum spanning tree in a graph. However, in Kruskal's, the graph does not have to be connected
  • Time Complexity: O(|E|log|V|)

Alt text

Greedy Algorithms

  • Greedy Algorithms are algorithms that make locally optimal choices at each step in the hope of eventually reaching the globally optimal solution
  • Problems must exhibit two properties in order to implement a Greedy solution:
  • Optimal Substructure
    • An optimal solution to the problem contains optimal solutions to the given problem's subproblems
  • The Greedy Property
    • An optimal solution is reached by "greedily" choosing the locally optimal choice without ever reconsidering previous choices
  • Example - Coin Change
    • Given a target amount V cents and a list of denominations of n coins, i.e. we have coinValue[i] (in cents) for coin types i from [0...n - 1], what is the minimum number of coins that we must use to represent amount V? Assume that we have an unlimited supply of coins of any type
    • Coins - Penny (1 cent), Nickel (5 cents), Dime (10 cents), Quarter (25 cents)
    • Assume V = 41. We can use the Greedy algorithm of continuously selecting the largest coin denomination less than or equal to V, subtract that coin's value from V, and repeat.
    • V = 41 | 0 coins used
    • V = 16 | 1 coin used (41 - 25 = 16)
    • V = 6 | 2 coins used (16 - 10 = 6)
    • V = 1 | 3 coins used (6 - 5 = 1)
    • V = 0 | 4 coins used (1 - 1 = 0)
    • Using this algorithm, we arrive at a total of 4 coins which is optimal

Bitmasks

  • Bitmasking is a technique used to perform operations at the bit level. Leveraging bitmasks often leads to faster runtime complexity and helps limit memory usage
  • Test kth bit: s & (1 << k);
  • Set kth bit: s |= (1 << k);
  • Turn off kth bit: s &= ~(1 << k);
  • Toggle kth bit: s ^= (1 << k);
  • Multiple by 2n: s << n;
  • Divide by 2n: s >> n;
  • Intersection: s & t;
  • Union: s | t;
  • Set Subtraction: s & ~t;
  • Extract lowest set bit: s & (-s);
  • Extract lowest unset bit: ~s & (s + 1);
  • Swap Values: x ^= y; y ^= x; x ^= y;

Runtime Analysis

Big O Notation

  • Big O Notation is used to describe the upper bound of a particular algorithm. Big O is used to describe worst case scenarios

Alt text

Little O Notation

  • Little O Notation is also used to describe an upper bound of a particular algorithm; however, Little O provides a bound that is not asymptotically tight

Big Ω Omega Notation

  • Big Omega Notation is used to provide an asymptotic lower bound on a particular algorithm

Alt text

Little ω Omega Notation

  • Little Omega Notation is used to provide a lower bound on a particular algorithm that is not asymptotically tight

Theta Θ Notation

  • Theta Notation is used to provide a bound on a particular algorithm such that it can be "sandwiched" between two constants (one for an upper limit and one for a lower limit) for sufficiently large values

Alt text

Video Lectures

Interview Books

Computer Science News

Directory Tree

.
├── Array
│   ├── bestTimeToBuyAndSellStock.java
│   ├── findTheCelebrity.java
│   ├── gameOfLife.java
│   ├── increasingTripletSubsequence.java
│   ├── insertInterval.java
│   ├── longestConsecutiveSequence.java
│   ├── maximumProductSubarray.java
│   ├── maximumSubarray.java
│   ├── mergeIntervals.java
│   ├── missingRanges.java
│   ├── productOfArrayExceptSelf.java
│   ├── rotateImage.java
│   ├── searchInRotatedSortedArray.java
│   ├── spiralMatrixII.java
│   ├── subsetsII.java
│   ├── subsets.java
│   ├── summaryRanges.java
│   ├── wiggleSort.java
│   └── wordSearch.java
├── Backtracking
│   ├── androidUnlockPatterns.java
│   ├── generalizedAbbreviation.java
│   └── letterCombinationsOfAPhoneNumber.java
├── BinarySearch
│   ├── closestBinarySearchTreeValue.java
│   ├── firstBadVersion.java
│   ├── guessNumberHigherOrLower.java
│   ├── pow(x,n).java
│   └── sqrt(x).java
├── BitManipulation
│   ├── binaryWatch.java
│   ├── countingBits.java
│   ├── hammingDistance.java
│   ├── maximumProductOfWordLengths.java
│   ├── numberOf1Bits.java
│   ├── sumOfTwoIntegers.java
│   └── utf-8Validation.java
├── BreadthFirstSearch
│   ├── binaryTreeLevelOrderTraversal.java
│   ├── cloneGraph.java
│   ├── pacificAtlanticWaterFlow.java
│   ├── removeInvalidParentheses.java
│   ├── shortestDistanceFromAllBuildings.java
│   ├── symmetricTree.java
│   └── wallsAndGates.java
├── DepthFirstSearch
│   ├── balancedBinaryTree.java
│   ├── battleshipsInABoard.java
│   ├── convertSortedArrayToBinarySearchTree.java
│   ├── maximumDepthOfABinaryTree.java
│   ├── numberOfIslands.java
│   ├── populatingNextRightPointersInEachNode.java
│   └── sameTree.java
├── Design
│   └── zigzagIterator.java
├── DivideAndConquer
│   ├── expressionAddOperators.java
│   └── kthLargestElementInAnArray.java
├── DynamicProgramming
│   ├── bombEnemy.java
│   ├── climbingStairs.java
│   ├── combinationSumIV.java
│   ├── countingBits.java
│   ├── editDistance.java
│   ├── houseRobber.java
│   ├── paintFence.java
│   ├── paintHouseII.java
│   ├── regularExpressionMatching.java
│   ├── sentenceScreenFitting.java
│   ├── uniqueBinarySearchTrees.java
│   └── wordBreak.java
├── HashTable
│   ├── binaryTreeVerticalOrderTraversal.java
│   ├── findTheDifference.java
│   ├── groupAnagrams.java
│   ├── groupShiftedStrings.java
│   ├── islandPerimeter.java
│   ├── loggerRateLimiter.java
│   ├── maximumSizeSubarraySumEqualsK.java
│   ├── minimumWindowSubstring.java
│   ├── sparseMatrixMultiplication.java
│   ├── strobogrammaticNumber.java
│   ├── twoSum.java
│   └── uniqueWordAbbreviation.java
├── LinkedList
│   ├── addTwoNumbers.java
│   ├── deleteNodeInALinkedList.java
│   ├── mergeKSortedLists.java
│   ├── palindromeLinkedList.java
│   ├── plusOneLinkedList.java
│   ├── README.md
│   └── reverseLinkedList.java
├── Queue
│   └── movingAverageFromDataStream.java
├── README.md
├── Sort
│   ├── meetingRoomsII.java
│   └── meetingRooms.java
├── Stack
│   ├── binarySearchTreeIterator.java
│   ├── decodeString.java
│   ├── flattenNestedListIterator.java
│   └── trappingRainWater.java
├── String
│   ├── addBinary.java
│   ├── countAndSay.java
│   ├── decodeWays.java
│   ├── editDistance.java
│   ├── integerToEnglishWords.java
│   ├── longestPalindrome.java
│   ├── longestSubstringWithAtMostKDistinctCharacters.java
│   ├── minimumWindowSubstring.java
│   ├── multiplyString.java
│   ├── oneEditDistance.java
│   ├── palindromePermutation.java
│   ├── README.md
│   ├── reverseVowelsOfAString.java
│   ├── romanToInteger.java
│   ├── validPalindrome.java
│   └── validParentheses.java
├── Tree
│   ├── binaryTreeMaximumPathSum.java
│   ├── binaryTreePaths.java
│   ├── inorderSuccessorInBST.java
│   ├── invertBinaryTree.java
│   ├── lowestCommonAncestorOfABinaryTree.java
│   ├── sumOfLeftLeaves.java
│   └── validateBinarySearchTree.java
├── Trie
│   ├── addAndSearchWordDataStructureDesign.java
│   ├── implementTrie.java
│   └── wordSquares.java
└── TwoPointers
    ├── 3Sum.java
    ├── 3SumSmaller.java
    ├── mergeSortedArray.java
    ├── minimumSizeSubarraySum.java
    ├── moveZeros.java
    ├── removeDuplicatesFromSortedArray.java
    ├── reverseString.java
    └── sortColors.java

18 directories, 124 files