Core Data Structures, Algorithms and Concepts

Graph: n nodes, m edges

Representation

Adjacency Matrix: O(n^2) space, not efficient for sparse graph

Adjacency List: O(n + m) space, efficient for sparse graph 

Traversal

BFS: Runtime: O(n + m)

application: unweighted graph shortest path computation, connected components of undirected graph detection

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.List;

class UndirectedGraphNode {
    int label;
    int shortestPathToSrc;
    ArrayList<UndirectedGraphNode> neighbors;
    UndirectedGraphNode(int x) { 
        label = x; 
        neighbors = new ArrayList<UndirectedGraphNode>(); 
    }
}
public class Graph {    
    //breath first search traversal of the entire graph
    //O(n + m) runtime, O(n) space
    public static void bfsUnweighted(UndirectedGraphNode node) {
        HashSet<UndirectedGraphNode> visited = new HashSet<UndirectedGraphNode>();
        Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
        queue.add(node);
        visited.add(node);
        while(!queue.isEmpty()) {
            UndirectedGraphNode currNode = queue.poll();
            for(UndirectedGraphNode neighbor : currNode.neighbors) {
                if(!visited.contains(neighbor)) {
                    queue.add(neighbor);
                    visited.add(neighbor);
                }
            }
        }
    }
    //single source multiple destinations using bfs
    //O(n + m) runtime, O(n) space
    public static void shortestPathUnweighted(UndirectedGraphNode source) {
        //Assume shortestPathtoSrc is set to Integer.MAX_VALUE in initialization
        source.shortestPathToSrc = 0;
        HashSet<UndirectedGraphNode> visited = new HashSet<UndirectedGraphNode>();
        Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
        queue.add(source);
        visited.add(source);
        while(!queue.isEmpty()) {
            UndirectedGraphNode currNode = queue.poll();
            for(UndirectedGraphNode neighbor : currNode.neighbors) {
                if(!visited.contains(neighbor)) {
                    neighbor.shortestPathToSrc = currNode.shortestPathToSrc + 1;
                    queue.add(neighbor);
                    visited.add(neighbor);
                }
            }
        }        
    }
    private static void bfsHelper(UndirectedGraphNode node, 
                                    HashSet<UndirectedGraphNode> visited, 
                                    List<Integer> component) {
        Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
        queue.add(node);
        visited.add(node);
        component.add(node.label);
        while(!queue.isEmpty()) {
            UndirectedGraphNode currNode = queue.poll();
            for(UndirectedGraphNode neighbor : currNode.neighbors) {
                if(!visited.contains(neighbor)) {
                    queue.add(neighbor);
                    visited.add(neighbor);
                    component.add(neighbor.label);
                }
            }
        }
    }
    //connected components on undirected graph via bfs
    //O(n + m) runtime
    public static List<List<Integer>> undirectedConnect(List<UndirectedGraphNode> nodes) {
        HashSet<UndirectedGraphNode> visited = new HashSet<UndirectedGraphNode>();
        List<List<Integer>> components = new ArrayList<List<Integer>>();
        for(UndirectedGraphNode node : nodes) {
            if(!visited.contains(node)) {
                List<Integer> component = new ArrayList<Integer>();
                bfsHelper(node, visited, component);
                components.add(component);
            }
        }
        return components;
    }
}

DFS: Runtime: O(n + m)

application: topological sorting of directed acyclic graph; strongly connected components of directed graphs

private static int topoOrder;

private static void dfsHelper(UndirectedGraphNode node, HashSet<UndirectedGraphNode> explored) {
    explored.add(node);
    for(UndirectedGraphNode neighbor : node.neighbors) {
        if(!explored.contains(neighbor)) {
            dfsHelper(neighbor, explored);
        }
    }
}
public static void dfs(UndirectedGraphNode node) {
    dfsHelper(node, new HashSet<UndirectedGraphNode>());
}

private static void topoSortDFS(DirectedGraphNode node, HashSet<DirectedGraphNode> explored) {
     explored.add(node);
     for(DirectedGraphNode neighbor: node.neighbors) {
         if(!explored.contains(neighbor)) {
             topoSortDFS(neighbor, explored);
         }
     }
     node.topoOrder = topoOrder;
     topoOrder -= 1;
}
public static void topoSort(ArrayList<DirectedGraphNode> graph) {
    topoOrder = graph.size();
    HashSet<DirectedGraphNode> explored = new HashSet<DirectedGraphNode>();
    for(DirectedGraphNode node : graph) {
        if(!explored.contains(node)) {
            topoSortDFS(node, explored);
        }
    }
}

Topologoical Sorting (Graph has no directed cycle:  O(n + m) runtime to compute topological ordering) && Cycle Detection

Can be done using DFS or BFS. 

Practice problems: 

Topological Sorting

Course Schedule

Course Schedule II

1. Directed Graph: convert to topological sorting problem

　　a. DFS: Using 3 sets: white, gray and black. white set contains vertices that have not been explored; gray set contains vertices that are being explored; black set contains vertices that have already been 

　　　　　　completely explored. O(n + m) runtime, O(n) space

　　b. BFS: Use the number of incoming edges as a criterion to determine which vertices should be put in topological order. If there is any cycles, then these vertices in cycles would never be explored. 　　　　　　Keeping a traversed vertex count tells us if there is any cycle or not.  O(n + m) runtime, O(n) space

2.  Undirected Graph:

　　a. DFS: O(n + m) runtime, O(n) space if not considering recursive call stack memory usage.

Algorithm: 1. create a hash set that tracks which vertices have been visited; 2. for each vertex, if it has not been visited, do a dfs starting from this vertex. At each dfs call, pass the source node so that following dfs calls do not go back to already visited source vertices. For a current vertex, if it finds one of its neighboring vertex is already visited and this neighbor is not the source vertex, there is a cycle.

    private static boolean undirectedGraphDfsHelper(UndirectedGraphNode currNode, UndirectedGraphNode srcNode,
                                                    HashSet<UndirectedGraphNode> explored) {
        explored.add(currNode);
        for(UndirectedGraphNode neighbor : currNode.neighbors) {
            if(neighbor == srcNode) {
                continue;
            }
            if(explored.contains(neighbor)) {
                return true;
            }
            if(undirectedGraphDfsHelper(neighbor, currNode, explored)) {
                return true;
            }
        }
        return false;
    }
    public static boolean detectCycleInUndirectedGraphDfs(ArrayList<UndirectedGraphNode> graph) {
        HashSet<UndirectedGraphNode> explored = new HashSet<UndirectedGraphNode>();
        for(UndirectedGraphNode node: graph) {
            if(explored.contains(node)) {
                continue;
            }
            if(undirectedGraphDfsHelper(node, null, explored)) {
                return true;
            }
        }
        return false;
    }

　　b. Union Find: O(n + m) runtime, O(n) space 

Algorithm:

1. create a map from vertex label to union find index for convenience purpose.

2. create an union find data structure for all vertices, with each's parent initialized to be itself.

3. iterate through all edges: check if the vertices on both end are part of the same union. If they are, it means there is another path between these two vertices. The current edge forms a cycle. If not, connect the two unions that these two vertices belong to.

public static boolean detectCycleInUndirectedGraphUf(ArrayList<UndirectedGraphNode> graph, ArrayList<Edge> edges) {
    HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
    for(int i = 0; i < graph.size(); i++) {
        map.put(graph.get(i).label, i);
    }
    UnionFind uf = new UnionFind(graph.size());
    for(Edge edge : edges) {
        UndirectedGraphNode node1 = edge.node1;
        UndirectedGraphNode node2 = edge.node2;
        int id1 = map.get(node1.label);
        int id2 = map.get(node2.label);
        if(uf.find(id1) == uf.find(id2)) {
            return true;
        }
        else {
            uf.connect(id1, id2);
        }
    }
    return false;
}

　　c. BFS needs some modification to make it work. If a neighbor vertex is not the current vertex's source and this neighbor has already been explored, it means there is another shorter bfs route to this 　　　　neighbor,  thus the edge between the current vertex and this neighbor makes up one edge of a cycle.

O(n + m) runtime, O(n) space

private static boolean undirectedGraphBfsHelper(UndirectedGraphNode node, 
                                                HashSet<UndirectedGraphNode> explored) {
    Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
    Queue<UndirectedGraphNode> source = new LinkedList<UndirectedGraphNode>();
    queue.add(node);
    source.add(null);
    explored.add(node);
    while(!queue.isEmpty()) {
        UndirectedGraphNode curr = queue.poll();
        UndirectedGraphNode src = source.poll();
        for(UndirectedGraphNode neighbor : curr.neighbors) {
            if(neighbor == src) {
                continue;
            }
            if(explored.contains(neighbor)) {
                return true;
            }
            queue.add(neighbor);
            source.add(curr);
            explored.add(neighbor);
        }
    }
    return false;
}
public static boolean detectCycleInUndirectedGraphBfs(ArrayList<UndirectedGraphNode> graph) {
    HashSet<UndirectedGraphNode> explored = new HashSet<UndirectedGraphNode>();
    for(UndirectedGraphNode node : graph) {
        if(explored.contains(node)) {
            continue;
        }
        if(undirectedGraphBfsHelper(node, explored)) {
            return true;
        }
    }
    return false;
}

Shortest Paths Algorithms

Unweighted graph: BFS to get the fewest number of edges;

Weighted graph: 

Single source shortest path:

Dijkstra's shortest path algorithm: works on both directed and undirected graph as long as all edge weights are non-negative. Greedy algorithm, similar with Prim's MST algorithm.

To get the optimized O(m log n) runtime solution, we need a modified heap data structure that supports O(logn) extractMin, O(logn) decrease key, O(1) node look up. 

package com.interview.graph;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Graph<T> {
    private List<Edge<T>> allEdges;
    private Map<Integer, Vertex<T>> allVertex;
    private boolean isDirected;
    public Graph(boolean isDirected) {
        this.allEdges = new ArrayList<Edge<T>>();
        this.allVertex = new HashMap<Integer, Vertex<T>>();
        this.isDirected = isDirected;
    }
    public void addEdge(int id1, int id2) {
        addEdge(id1, id2, 0);
    }
    public void addVertex(Vertex<T> vertex) {
        if(allVertex.containsKey(vertex.getId())) {
            return;
        }
        allVertex.put(vertex.getId(), vertex);
        
    }
    public Vertex<T> getVertex(int id) {
        return null;
    }
    public void addEdge(int id1, int id2, int weight) {
        
    }
    public List<Edge<T>> getAllEdges() {
        return null;
    }
    public Collection<Vertex<T>> getAllVertex() {
        return allVertex.values();
    }
    public void setDataForVertex(int id, T data) {
        
    }
    public String toString() {
        return null;
    }
}

class Vertex<T> {
    int id;
    private T data;
    private List<Edge<T>> edges = new ArrayList<>();
    private List<Vertex<T>> adjacentVertex = new ArrayList<>();
    
    Vertex(int id) {
        this.id = id;
    }
    public int getId() {
        return this.id;
    }
    public void setData(T data) {
        this.data = data;
    }
    public T getData() {
        return this.data;
    }
    public void addAdjacentVertex(Edge<T> e, Vertex<T> v) {
        edges.add(e);
        adjacentVertex.add(v);
    }
    public String toString() {
        return String.valueOf(id);
    }
    public List<Edge<T>> getEdges() {
        return edges;
    }
    public int getDegree() {
        return edges.size();
    }
    
    public int hashCode() {
        int hash = 1;
        hash = hash * 31 + id;
        return hash;
    }
    public boolean equals(Object obj) {
        //reference equality
        if(this == obj) {
            return true;
        }
        if(obj == null) {
            return false;
        }
        //if(getClass() != obj.getClass())
        if(!(obj instanceof Vertex<?>)) {
            return false;
        }
        Vertex<T> other = (Vertex<T>) obj;
        if(id != other.id) {
            return false;
        }
        return true;
    }
}
class Edge<T> {
    private boolean isDirected = false;
    private Vertex<T> vertex1;
    private Vertex<T> vertex2;
    private int weight;
    
    Edge(Vertex<T> v1, Vertex<T> v2) {
        vertex1 = v1;
        vertex2 = v2;
    }
    
    Edge(Vertex<T> v1, Vertex<T> v2, boolean directed, int weight) {
        this(v1, v2);
        this.isDirected = directed;
        this.weight = weight;
    }
    
    Edge(Vertex<T> v1, Vertex<T> v2, boolean directed) {
        this(v1, v2);
        this.isDirected = directed;
    }
    
    Vertex<T> getVertex1() {
        return vertex1;
    }
    
    Vertex<T> getVertex2() {
        return vertex2;
    }
    
    int getWeight() {
        return weight;
    }
    
    boolean isDirected() {
        return isDirected;
    }
    
    public int hashCode() {
        int hash = 1;
        hash = hash * 31 + ((vertex1 == null) ? 0 : vertex1.hashCode());
        hash = hash * 31 + ((vertex2 == null) ? 0 : vertex2.hashCode());
        return hash;
    }
    
    public boolean equals(Object obj) {
        if(this == obj) {
            return true;
        }
        if(obj == null) {
            return false;
        }
        if(getClass() != obj.getClass()) {
            return false;
        }
        Edge<T> other = (Edge<T>) obj;
        if(!vertex1.equals(other.vertex1) || !vertex2.equals(other.vertex2)) {
            return false;
        }
        return true;
    }
    
    public String toString() {
        return "Edge [isDirected = " + isDirected + ", vertex1 = " + vertex1 + ", vertex2 = " + vertex2
                + ", weight = " + weight + "]";
    }
}

package com.interview.graph;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/*
 * poll(): O(logn)
 * add(): O(logn)
 * containsData: O(1)
 * decreaseDataWeight: O(logn)
 * getDataWeight: O(1)
 */

public class BinaryMinHeap<T> {
    private List<Node> allNodes = new ArrayList<>();
    private Map<T, Integer> nodePosition = new HashMap<>();
    class Node {
        int weight;
        T data;
    }

    public boolean containsData(T data) {
        return nodePosition.containsKey(data);
    }
    
    public void add(T data, int weight) {
        Node node = new Node();
        node.data = data;
        node.weight = weight;
        allNodes.add(node);
        
        //percolate up 
        int currentIdx = allNodes.size() - 1;
        while(currentIdx > 0 && weight < allNodes.get((currentIdx - 1) / 2).weight) {
            Node temp = allNodes.get((currentIdx - 1) / 2);
            allNodes.set(currentIdx, temp);
            nodePosition.put(temp.data, currentIdx);
            currentIdx = (currentIdx - 1) / 2;
        }
        allNodes.set(currentIdx, node);
        nodePosition.put(node.data, currentIdx);
    }
    
    public T peek() {
        return allNodes.get(0).data;
    }
    public Node pollMinNode() {
        Node min = allNodes.get(0);
        nodePosition.remove(min.data);
        //swap the min node with the last node 
        Node lastNode = allNodes.get(allNodes.size() - 1);
        allNodes.set(0, lastNode);
        allNodes.remove(allNodes.size() - 1);
        
        //percolate down 
        int currIdx = 0, minIdx;
        int leftChildIdx, rightChildIdx;
        while(true) {
            minIdx = currIdx;
            leftChildIdx = 2 * currIdx + 1;
            rightChildIdx = 2 * currIdx + 2;
            if(leftChildIdx >= allNodes.size()) {
                break;
            }
            else if(allNodes.get(leftChildIdx).weight < allNodes.get(currIdx).weight) {
                minIdx = leftChildIdx;
            }
            if(rightChildIdx < allNodes.size() && allNodes.get(rightChildIdx).weight < allNodes.get(minIdx).weight) {
                minIdx = rightChildIdx;
            }
            if(minIdx != currIdx) {
                Node currNode = allNodes.get(currIdx);
                Node minNode = allNodes.get(minIdx);
                allNodes.set(currIdx, minNode);
                allNodes.set(minIdx, currNode);
                nodePosition.put(minNode.data, currIdx);
                currIdx = minIdx;
            }
            else {
                break;
            }
        }
        return min;
    }
    public T poll() {
        return pollMinNode().data;
    }
    
    public boolean isEmpty() {
        return allNodes.size() == 0;
    }
    
    public void decreaseDataWeight(T data, int newWeight) {
        int currentIdx = nodePosition.get(data);
        Node changedNode = allNodes.get(currentIdx);
        changedNode.weight = newWeight;
        
        //percolate up
        while(currentIdx > 0 && newWeight < allNodes.get((currentIdx - 1) / 2).weight) {
            Node temp = allNodes.get((currentIdx - 1) / 2);
            allNodes.set(currentIdx, temp);
            nodePosition.put(temp.data, currentIdx);
            currentIdx = (currentIdx - 1) / 2;            
        }
        allNodes.set(currentIdx, changedNode);
        nodePosition.put(changedNode.data, currentIdx);
    }
    
    public int getDataWeight(T data) {
        return nodePosition.get(data);
    }
}

package com.interview.graph;

import java.util.HashMap;
import java.util.Map;

public class DijkstraShortestPath {
    public Map<Vertex<Integer>, Integer> shortestPath(Graph<Integer> graph, Vertex<Integer> sourceVertex) {
        //min heap that supports O(1) look up
        BinaryMinHeap<Vertex<Integer>> minHeap = new BinaryMinHeap<>();
        
        //stores shortest distance from source to every vertex
        Map<Vertex<Integer>, Integer> distance = new HashMap<>();
        
        Map<Vertex<Integer>, Vertex<Integer>> parent = new HashMap<>();
        
        for(Vertex<Integer> vertex : graph.getAllVertex()) {
            minHeap.add(vertex, Integer.MAX_VALUE);
        }
        
        minHeap.decreaseDataWeight(sourceVertex, 0);
        distance.put(sourceVertex, 0);
        parent.put(sourceVertex, null);
        
        while(!minHeap.isEmpty()) {
            BinaryMinHeap<Vertex<Integer>>.Node heapNode = minHeap.pollMinNode();
            Vertex<Integer> currVertex = heapNode.data;
            
            distance.put(currVertex, heapNode.weight);
            for(Edge<Integer> e : currVertex.getEdges()) {
                Vertex<Integer> neighbor = getVertexForEdge(currVertex, e);
                if(!minHeap.containsData(neighbor)) {
                    continue;
                }
                int newDistance = distance.get(currVertex) + e.getWeight();
                if(newDistance < minHeap.getDataWeight(neighbor)) {
                    minHeap.decreaseDataWeight(neighbor, newDistance);
                    parent.put(neighbor, currVertex);
                }
            }
        }
        return distance;
    }
    
    private Vertex<Integer> getVertexForEdge(Vertex<Integer> v, Edge<Integer> e) {
        return e.getVertex1().equals(v) ? e.getVertex2() : e.getVertex1();
    }
}

Bellman-Ford shortest path algorithm: O(n * m) runtime, O(n) space, works with negative edge weight as long as there is no negative cycle. Similar with Dynamic Programming Principle.

package com.interview.graph;
import java.util.HashMap;
import java.util.Map;

public class BellmanFord {
    private static final int INF = 10000000;
    public Map<Vertex<Integer>, Integer> BellmanFordShortestPath(Graph<Integer> graph, Vertex<Integer> sourceVertex) {
        Map<Vertex<Integer>, Integer> distance = new HashMap<>();
        Map<Vertex<Integer>, Vertex<Integer>> parent = new HashMap<>();
        
        for(Vertex<Integer> v : graph.getAllVertex()) {
            distance.put(v, INF);
            parent.put(v, null);
        }
        distance.put(sourceVertex, 0);
        int n = graph.getAllVertex().size();
        boolean isUpdated = false;
        for(int i = 0; i < n - 1; i++) {
            for(Edge<Integer> e : graph.getAllEdges()) {
                Vertex<Integer> u = e.getVertex1();
                Vertex<Integer> v = e.getVertex2();
                if(distance.get(u) + e.getWeight() < distance.get(v)) {
                    distance.put(v, distance.get(u) + e.getWeight());
                    parent.put(v, u);
                    isUpdated = true;
                }
            }
            //terminate early if there is no path updates between two iterations
            if(!isUpdated) {
                return distance;
            }
        }

        //do one more iteration for possible negative cycle detection 
        for(Edge<Integer> e : graph.getAllEdges()) {
            Vertex<Integer> u = e.getVertex1();
            Vertex<Integer> v = e.getVertex2();
            if(distance.get(u) + e.getWeight() < distance.get(v)) {
                return null;
            }            
        }
        return distance;
    }
}

Prim Minimum Spanning Tree(one solution is to use union find)

 Pratice problem:  Minimum Spanning Tree

More Graph practice problems

Search Graph Nodes

Graph Valid Tree

Clone Graph

Six Degrees

Connected Component in Undirected Graph

Find the Weak Connected Component in the Directed Graph

Connecting Graph

Connecting Graph II

Connecting Graph III 

Union Find(Disjoint Sets)

Operations:

makeSet() or UnionFind(): O(1) runtime

findSet() or find(): O(1) runtime on average

union() or connect(): O(1) runtime 

 

Tree Implementation using union rank and path compression 

import java.util.HashMap;
import java.util.Map;

public class UnionFind {
    private Map<Integer, Node> map = new HashMap<Integer, Node>();
    
    class Node {
        int data;
        int rank;
        Node parent;
    }
    public UnionFind(int data) {
        Node node = new Node();
        node.data = data;
        node.rank = 0;
        node.parent = node;
        map.put(data, node);
    }
    //Combines two sets together to one by rank
    public void union(int data1, int data2) {
        Node node1 = map.get(data1);
        Node node2 = map.get(data2);
        
        Node parent1 = find(node1);
        Node parent2 = find(node2);
        
        //if they are part of the the same set, do nothing 
        if(parent1.data == parent2.data) {
            return;
        }
        //else whoever's rank is higher becomes parent of the other set
        if(parent1.rank >= parent2.rank) {
            //increment rank only if both sets have the same rank
            parent1.rank = (parent1.rank == parent2.rank) ? parent1.rank + 1 : parent1.rank;
            parent2.parent = parent1;
        }
        else {
            parent1.parent = parent2;
        }
    }
    //Find the representative of this set 
    public int find(int data) {
        return find(map.get(data)).data;
    }
    //Find the representative recursively and does path compression as well 
    private Node find(Node node) {
        Node parent = node.parent;
        if(parent == node) {
            return parent;
        }
        node.parent = find(node.parent);
        return node.parent;
    }
}

Simplified Array Implementation using path compression

public class UnionFind {
    private int[] parent = null;
    private int unionCount = 0;
    
    public UnionFind(int n){
        unionCount = 0;
        parent = new int[n];
        for(int i = 0; i < n; i++){
            parent[i] = i;
        }
    }
    
    public int find(int x){
        if(parent[x] == x){
            return x;
        }
        return parent[x] = find(parent[x]);
    }
    
    public void connect(int a, int b){
        int root_a = find(a);
        int root_b = find(b);
        if(root_a != root_b){
            parent[root_a] = root_b;
            unionCount--;
        }
    }   
    
    public int getTotalUnionNum(){
        return unionCount;
    }
}

Heap(PriorityQueue)

Practice Problems

Heapify

HeapSort

High Five

Top K Largest Numbers 

Top K Largest Numbers II

K Closest Points

K Closest Numbers in Sorted Array

Kth Largest Element

Kth Largest Element II

Merge K Sorted Lists

Merge K Sorted Arrays

Top K Frequent Words 

Ugly Number II

Longest Consecutive Sequence 

 

 

Trie 

Trie vs Hash

 

Practice Problems

Implement Trie

 

package com.interview.trie;

import java.util.HashMap;

class TrieNode {
    char c;
    HashMap<Character, TrieNode> children = null;
    boolean endOfWord;
    TrieNode() {
        children = new HashMap<Character, TrieNode>();
    }
    TrieNode(char c) {
        children = new HashMap<Character, TrieNode>();
        this.c = c;
    }
}
public class Trie {
    private TrieNode root;
    public Trie() {
        root = new TrieNode();
    }
    //insert a word into trie
    public void insert(String word) {
        TrieNode curr = root;
        HashMap<Character, TrieNode> currChildren = curr.children;
        char[] wordArray = word.toCharArray();
        for(int i = 0; i < wordArray.length; i++) {
            char currChar = wordArray[i];
            if(currChildren.containsKey(currChar)) {
                curr = currChildren.get(currChar);
            }
            else {
                TrieNode newNode = new TrieNode(currChar);
                currChildren.put(currChar, newNode);
                curr = newNode;
            }
            currChildren = curr.children;
            if(i == wordArray.length - 1) {
                curr.endOfWord = true;
            }
        }
    }
    //search if a word is in trie
    public boolean search(String word) {
        TrieNode lastCharNode = searchLastWordNode(word);
        return lastCharNode != null && lastCharNode.endOfWord == true;
    }
    //check if there is any word in trie that starts with a given prefix
    public boolean startsWith(String prefix) {
        TrieNode lastCharNode = searchLastWordNode(prefix);
        return lastCharNode != null;
    }
    //return the trie node corresponding to the last character of given string s
    //return null if no match
    private TrieNode searchLastWordNode(String s) {
        TrieNode curr = root;
        HashMap<Character, TrieNode> currChildren = root.children;
        char[] chars = s.toCharArray();
        for(int i = 0; i < chars.length; i++) {
            char currChar = chars[i];
            if(currChildren.containsKey(currChar)) {
                curr = currChildren.get(currChar);
                currChildren = curr.children;
            }
            else {
                return null;
            }
        }
        return curr;
    }
}

 

Tree

 Binary Tree preorder, inorder and postorder traversal, recursion and iteration

 

package com.interview.tree;

import java.util.Stack;

class BinaryTreeNode<T> {
    T data;
    BinaryTreeNode<T> left;
    BinaryTreeNode<T> right;
    BinaryTreeNode(T data) {
        this.data = data;
        left = null;
        right = null;
    }
}
public class BinaryTree<T> {
    public void preOrderRecursion(BinaryTreeNode<T> root) {
        if(root == null) {
            return;
        }
        visitNode(root);
        preOrderRecursion(root.left);
        preOrderRecursion(root.right);
    }
    public void preOrderIteration(BinaryTreeNode<T> root) {
        if(root == null) {
            return;
        }
        Stack<BinaryTreeNode<T>> stack = new Stack<BinaryTreeNode<T>>();
        BinaryTreeNode<T> currNode = root;
        
        while(currNode != null || !stack.empty()) {
            if(currNode != null) {
                visitNode(currNode);
                stack.push(currNode);
                currNode = currNode.left;
            }
            else {
                currNode = stack.pop();
                currNode = currNode.right;
            }
        }
    }
    public void inOrderRecursion(BinaryTreeNode<T> root) {
        if(root == null) {
            return;
        }
        inOrderRecursion(root.left);
        visitNode(root);
        inOrderRecursion(root.right);
    }
    public void inOrderIteration(BinaryTreeNode<T> root) {
        if(root == null) {
            return;
        }
        Stack<BinaryTreeNode<T>> stack = new Stack<BinaryTreeNode<T>>();
        BinaryTreeNode<T> currNode = root;
        
        while(currNode != null || !stack.empty()) {
            if(currNode != null) {
                stack.push(currNode);
                currNode = currNode.left;
            }
            else {
                currNode = stack.pop();
                visitNode(currNode);
                currNode = currNode.right;                
            }
        }
    }
    public void postOrderRecursion(BinaryTreeNode<T> root) {
        if(root == null) {
            return;
        }
        postOrderRecursion(root.left);
        postOrderRecursion(root.right);
        visitNode(root);
    }
    public void postOrderIteration(BinaryTreeNode<T> root) {
        if(root == null) {
            return;
        }
        Stack<BinaryTreeNode<T>> stack = new Stack<BinaryTreeNode<T>>();
        BinaryTreeNode<T> currNode = root;
        BinaryTreeNode<T> prevNode = null;
        BinaryTreeNode<T> topNode = null;
        
        while(currNode != null || !stack.empty()) {
            if(currNode != null) {
                stack.push(currNode);
                currNode = currNode.left;
            }
            else {
                topNode = stack.peek();
                //first time traversing back to parent node
                //parent node has a non-null right child node and the previously visited node is not 
                //this right child node. This is the first time currnet parent is visited, time to 
                //visit its right child node
                if(topNode.right != null && prevNode != topNode.right) {
                    currNode = topNode.right;
                }
                //either the current parent node has no right child node or the previously visited node
                //is the non-null right child node
                //this is the second time current parent node is visited, time to visit this parent node
                else {
                    visitNode(topNode);
                    prevNode = topNode;
                    stack.pop();
                }
            }
        }
    }
    private void visitNode(BinaryTreeNode<T> node) {
        
    }
}

Binary Search Tree Implementation

package com.interview.tree;

public class BinarySearchTree {
    public void insert(BinaryTreeNode<Integer> root, int data) {
        BinaryTreeNode<Integer> curr = root;
        while(curr.data != data) {
            if(curr.data > data) {
                if(curr.left == null) {
                    curr.left = new BinaryTreeNode<Integer>(data);
                    return;
                }
                curr = curr.left;
            }
            else {
                if(curr.right == null) {
                    curr.right = new BinaryTreeNode<Integer>(data);
                    return;
                }
                curr = curr.right;
            }
        }
    }
    
    public boolean search(BinaryTreeNode<Integer> root, int data) {
        if(data < root.data) {
            return search(root.left, data);
        }
        else if(data > root.data) {
            return search(root.right, data);
        }
        return true;
    }
    
    public void remove(BinaryTreeNode<Integer> root, int data) {
        
    }
}

Stack && Queue

 

Hash Table

 

Array && Linked List && Two Pointers && Sorting

Merge sort, quick sort and heap sort implementation 

Two Pointers practice problems, two sums, 3 sums

package com.interview.sort;

import java.util.Random;

public class Sort {
    //O(nlogn) runtime, O(n) space
    public static void mergeSort(int[] a) {
        if(a == null || a.length <= 1) {
            return;
        }
        int[] aux = new int[a.length];
        mergeSortHelper(a, aux, 0, a.length - 1);
    }
    private static void mergeSortHelper(int[] a, int[] aux, int start, int end) {
        if(start >= end) {
            return;
        }
        int mid = start + (end - start) / 2;
        mergeSortHelper(a, aux, start, mid);
        mergeSortHelper(a, aux, mid + 1, end);
        merge(a, aux, start, end);
    }
    private static void merge(int[] a, int[] aux, int start, int end) {
        for(int k = start; k <= end; k++) {
            aux[k] = a[k];
        }
        int i = start, mid = start + (end - start) / 2, j = mid + 1;
        for(int k = start; k <= end; k++) {
            if(i > mid) {
                a[k] = aux[j++];
            }
            else if(j > end) {
                a[k] = aux[i++];
            }
            else if(aux[i] < aux[j]) {
                a[k] = aux[i++];
            }
            else {
                a[k] = aux[j++];
            }
        }
    }
    
    //O(nlogn) runtime on average, O(1) space 
    public static void quickSort(int[] a) {
        Random rand = new Random();
        quickSortHelper(a, rand, 0, a.length - 1);
    }
    private static void quickSortHelper(int[] a, Random rand, int start, int end) {
        if(start >= end) {
            return;
        }
        //choose pivot
        int p = rand.nextInt(end - start + 1) + start;
        
        //partition a around a[p]
        int pivot_sort_idx = partition(a, p, start, end);
        quickSortHelper(a, rand, start, pivot_sort_idx - 1);
        quickSortHelper(a, rand, pivot_sort_idx + 1, end);
    }
    private static int partition(int[] a, int pivot_index, int start, int end) {
        int pivot = a[pivot_index];
        swap(a, pivot_index, start);
        
        int i = start + 1, j = i;
        for(; j <= end; j++) {
            if(a[j] < pivot) {
                swap(a, i, j);
                i++;
            }
        }
        swap(a, start, i - 1);
        return i - 1;
    }

    private static void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    
    //O(nlogn) runtime, O(1) space 
    public static void heapSort(int[] a) {
        if(a == null || a.length <= 1) {
            return;
        }
        int n = a.length;
        
        //Build max heap, O(n) runtime
        for(int i = n / 2 - 1; i >= 0; i++) {
            heapify(a, n, i);
        }
        
        //one by one extract the largest element from heap, O(nlogn) runtime
        for(int i = n - 1; i > 0; i++) {
            //move current root of heap to end
            swap(a, 0, i);
            heapify(a, i, 0);
        }
    }
    private static void heapify(int[] a, int len, int rootIdx) {
        int largestIdx = rootIdx;
        int leftChildIdx = 2 * rootIdx + 1;
        int rightChildIdx = 2 * rootIdx + 2;
        
        //if left child is larger than root
        if(leftChildIdx < len && a[leftChildIdx] > a[largestIdx]) {
            largestIdx = leftChildIdx;
        }
        //if right child is larger than largest so far
        if(rightChildIdx < len && a[rightChildIdx] > a[largestIdx]) {
            largestIdx = rightChildIdx;
        }
        if(largestIdx != rootIdx) {
            swap(a, rootIdx, largestIdx);
            
            heapify(a, len, largestIdx);
        }
    }
}

Binary Search 

1. Recursion vs Iterative: if not using recursion, will the implementation becomes complex? Can the depth of recursion calls get big? 

2. How to avoid dead loop?

3. O(logn) runtime

4.  Binary search 3 different application scenarios.

　　a. Binary search on Index: Find the first or last position that meets certain conditions.

　　practice problems:

　　First/Last Position of Target

　　Classic Binary Search

　　Search a 2D Matrix:  Convert the 2D matrix's index into a 1D array then apply binary search. mid value should be declared as type long. 

　　Search a 2D Matrix II 

 　   Search in Rotated Sorted Array

　　Search in Rotated Sorted Array II

　　Find Minimum in Rotated Sorted Array

　　Find Minimum in Rotated Sorted Array II

　　Search in a Big Sorted Array

　　First Bad Version

　　b. Binary search to cut half of the exploring sets. Either keep the half that has an answer, or get rid of the half that does not have an answer.

　　practice problems: 

　　Closet Number in Sorted Array

　　K Closest Numbers in Sorted Array

　　Maximum Number in Mountain Sequence 

　　Find Peak Element

　　c. Binary Search on Result.

 

 

Recursion && Dynamic Programming

Two important principles of dynamic programming: 1. optimal substructure; 2. overlapping subproblems

Practice Problems 

Unique Paths 

Unique Paths II

Climbing Stairs

Minimum Path Sum

Triangle

Binary Tree Maximum Path Sum

Largest Divsible Subset

Knight Shortest Path

Knight Shortest Path II

Perfect Squares

Jump Game

Longest Increasing Subsequence

Drop Eggs 

Drop Eggs II

Bit Manipulation

Practice Problems

A + B Problem

+ operation can be simulated with bitwise xor ^ and bitwise and & operations. ^ takes care of bits addition; & takes care of carry bits.

O(1) Check Power of 2

Flip Bits

Count 1 in Binary

Left Rotate Bits