code
stringlengths 23
201k
| docstring
stringlengths 17
96.2k
| func_name
stringlengths 0
235
| language
stringclasses 1
value | repo
stringlengths 8
72
| path
stringlengths 11
317
| url
stringlengths 57
377
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
public ListNode mergeKLists(ListNode[] lists) {
if (lists==null||lists.length==0) {
return null;
}
PriorityQueue<ListNode> queue= new PriorityQueue<ListNode>(lists.length,new Comparator<ListNode>(){
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
});
ListNode dummy = new ListNode(0);
ListNode tail=dummy;
for (ListNode node:lists) {
if (node!=null) {
queue.add(node);
}
}
while (!queue.isEmpty()){
tail.next=queue.poll();
tail=tail.next;
if (tail.next!=null) {
queue.add(tail.next);
}
}
return dummy.next;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
mergeKLists
|
java
|
kdn251/interviews
|
company/facebook/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/company/facebook/MergeKSortedLists.java
|
MIT
|
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
compare
|
java
|
kdn251/interviews
|
company/facebook/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/company/facebook/MergeKSortedLists.java
|
MIT
|
public boolean isPalindrome(ListNode head) {
if(head == null || head.next == null) {
return true;
}
Stack<Integer> stack = new Stack<Integer>();
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null) {
stack.push(slow.val);
fast = fast.next.next;
slow = slow.next;
}
if(fast != null) {
slow = slow.next;
}
while(slow != null) {
if(stack.pop() != slow.val) {
return false;
}
slow = slow.next;
}
return true;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
isPalindrome
|
java
|
kdn251/interviews
|
company/facebook/PalindromeLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/company/facebook/PalindromeLinkedList.java
|
MIT
|
public ListNode reverseList(ListNode head) {
if(head == null) {
return head;
}
ListNode newHead = null;
while(head != null) {
ListNode next = head.next;
head.next = newHead;
newHead = head;
head = next;
}
return newHead;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
reverseList
|
java
|
kdn251/interviews
|
company/facebook/ReverseLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/company/facebook/ReverseLinkedList.java
|
MIT
|
public int sumOfLeftLeaves(TreeNode root) {
if(root == null) {
return 0;
}
int total = 0;
if(root.left != null) {
if(root.left.left == null && root.left.right == null) {
total += root.left.val;
} else {
total += sumOfLeftLeaves(root.left);
}
}
total += sumOfLeftLeaves(root.right);
return total;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
sumOfLeftLeaves
|
java
|
kdn251/interviews
|
company/facebook/SumOfLeftLeaves.java
|
https://github.com/kdn251/interviews/blob/master/company/facebook/SumOfLeftLeaves.java
|
MIT
|
public boolean isValidBST(TreeNode root) {
if(root == null) {
return true;
}
return validBSTRecursive(root, Long.MIN_VALUE, Long.MAX_VALUE);
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
isValidBST
|
java
|
kdn251/interviews
|
company/facebook/ValidateBinarySearchTree.java
|
https://github.com/kdn251/interviews/blob/master/company/facebook/ValidateBinarySearchTree.java
|
MIT
|
public boolean validBSTRecursive(TreeNode root, long minValue, long maxValue) {
if(root == null) {
return true;
} else if(root.val >= maxValue || root.val <= minValue) {
return false;
} else {
return validBSTRecursive(root.left, minValue, root.val) && validBSTRecursive(root.right, root.val, maxValue);
}
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
validBSTRecursive
|
java
|
kdn251/interviews
|
company/facebook/ValidateBinarySearchTree.java
|
https://github.com/kdn251/interviews/blob/master/company/facebook/ValidateBinarySearchTree.java
|
MIT
|
public boolean hasNext() {
return stack.isEmpty() ? false : true;
}
|
@return whether we have a next smallest number
|
hasNext
|
java
|
kdn251/interviews
|
company/google/BinarySearchTreeIterator.java
|
https://github.com/kdn251/interviews/blob/master/company/google/BinarySearchTreeIterator.java
|
MIT
|
public List<String> binaryTreePaths(TreeNode root) {
List<String> result = new ArrayList<String>();
if(root == null) {
return result;
}
helper(new String(), root, result);
return result;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
binaryTreePaths
|
java
|
kdn251/interviews
|
company/google/BinaryTreePaths.java
|
https://github.com/kdn251/interviews/blob/master/company/google/BinaryTreePaths.java
|
MIT
|
public void helper(String current, TreeNode root, List<String> result) {
if(root.left == null && root.right == null) {
result.add(current + root.val);
}
if(root.left != null) {
helper(current + root.val + "->", root.left, result);
}
if(root.right != null) {
helper(current + root.val + "->", root.right, result);
}
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
helper
|
java
|
kdn251/interviews
|
company/google/BinaryTreePaths.java
|
https://github.com/kdn251/interviews/blob/master/company/google/BinaryTreePaths.java
|
MIT
|
public List<List<Integer>> verticalOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
if(root == null) {
return result;
}
Map<Integer, ArrayList<Integer>> map = new HashMap<>();
Queue<TreeNode> q = new LinkedList<>();
Queue<Integer> cols = new LinkedList<>();
q.add(root);
cols.add(0);
int min = 0;
int max = 0;
while(!q.isEmpty()) {
TreeNode node = q.poll();
int col = cols.poll();
if(!map.containsKey(col)) {
map.put(col, new ArrayList<Integer>());
}
map.get(col).add(node.val);
if(node.left != null) {
q.add(node.left);
cols.add(col - 1);
min = Math.min(min, col - 1);
}
if(node.right != null) {
q.add(node.right);
cols.add(col + 1);
max = Math.max(max, col + 1);
}
}
for(int i = min; i <= max; i++) {
result.add(map.get(i));
}
return result;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
verticalOrder
|
java
|
kdn251/interviews
|
company/google/BinaryTreeVerticalOrderTraversal.java
|
https://github.com/kdn251/interviews/blob/master/company/google/BinaryTreeVerticalOrderTraversal.java
|
MIT
|
public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
if(node == null) {
return null;
}
if(map.containsKey(node.label)) {
return map.get(node.label);
}
UndirectedGraphNode newNode = new UndirectedGraphNode(node.label);
map.put(newNode.label, newNode);
for(UndirectedGraphNode neighbor : node.neighbors) {
newNode.neighbors.add(cloneGraph(neighbor));
}
return newNode;
}
|
Definition for undirected graph.
class UndirectedGraphNode {
int label;
List<UndirectedGraphNode> neighbors;
UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
};
|
cloneGraph
|
java
|
kdn251/interviews
|
company/google/CloneGraph.java
|
https://github.com/kdn251/interviews/blob/master/company/google/CloneGraph.java
|
MIT
|
public int closestValue(TreeNode root, double target) {
int value = root.val;
TreeNode child = root.val < target ? root.right : root.left;
if(child == null) {
return value;
}
int childValue = closestValue(child, target);
return Math.abs(value - target) < Math.abs(childValue - target) ? value : childValue;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
closestValue
|
java
|
kdn251/interviews
|
company/google/ClosestBinarySearchTreeValue.java
|
https://github.com/kdn251/interviews/blob/master/company/google/ClosestBinarySearchTreeValue.java
|
MIT
|
@Override
public Integer next() {
return stack.pop().getInteger();
}
|
// This is the interface that allows for creating nested lists.
// You should not implement it, or speculate about its implementation
public interface NestedInteger {
// @return true if this NestedInteger holds a single integer, rather than a nested list.
public boolean isInteger();
// @return the single integer that this NestedInteger holds, if it holds a single integer
// Return null if this NestedInteger holds a nested list
public Integer getInteger();
// @return the nested list that this NestedInteger holds, if it holds a nested list
// Return null if this NestedInteger holds a single integer
public List<NestedInteger> getList();
}
|
next
|
java
|
kdn251/interviews
|
company/google/FlattenNestedListIterator.java
|
https://github.com/kdn251/interviews/blob/master/company/google/FlattenNestedListIterator.java
|
MIT
|
@Override
public boolean hasNext() {
while(!stack.isEmpty()) {
NestedInteger current = stack.peek();
if(current.isInteger()) {
return true;
}
stack.pop();
for(int i = current.getList().size() - 1; i >= 0; i--) {
stack.push(current.getList().get(i));
}
}
return false;
}
|
// This is the interface that allows for creating nested lists.
// You should not implement it, or speculate about its implementation
public interface NestedInteger {
// @return true if this NestedInteger holds a single integer, rather than a nested list.
public boolean isInteger();
// @return the single integer that this NestedInteger holds, if it holds a single integer
// Return null if this NestedInteger holds a nested list
public Integer getInteger();
// @return the nested list that this NestedInteger holds, if it holds a nested list
// Return null if this NestedInteger holds a single integer
public List<NestedInteger> getList();
}
|
hasNext
|
java
|
kdn251/interviews
|
company/google/FlattenNestedListIterator.java
|
https://github.com/kdn251/interviews/blob/master/company/google/FlattenNestedListIterator.java
|
MIT
|
public boolean insert(int val) {
if(!map.containsKey(val)) {
map.put(val, val);
values.add(val);
return true;
}
else {
return false;
}
}
|
Inserts a value to the set. Returns true if the set did not already contain the specified element.
|
insert
|
java
|
kdn251/interviews
|
company/google/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/google/InsertDeleteGetRandomO1.java
|
MIT
|
public boolean remove(int val) {
if(map.containsKey(val)) {
map.remove(val);
values.remove(values.indexOf(val));
return true;
}
return false;
}
|
Removes a value from the set. Returns true if the set contained the specified element.
|
remove
|
java
|
kdn251/interviews
|
company/google/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/google/InsertDeleteGetRandomO1.java
|
MIT
|
public int getRandom() {
int random = (int)(Math.random() * values.size());
int valueToReturn = values.get(random);
return map.get(valueToReturn);
}
|
Get a random element from the set.
|
getRandom
|
java
|
kdn251/interviews
|
company/google/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/google/InsertDeleteGetRandomO1.java
|
MIT
|
public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
int i = 0;
while(i < intervals.size() && intervals.get(i).end < newInterval.start) {
i++;
}
while(i < intervals.size() && intervals.get(i).start <= newInterval.end) {
newInterval = new Interval(Math.min(intervals.get(i).start, newInterval.start), Math.max(intervals.get(i).end, newInterval.end));
intervals.remove(i);
}
intervals.add(i, newInterval);
return intervals;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
insert
|
java
|
kdn251/interviews
|
company/google/InsertInterval.java
|
https://github.com/kdn251/interviews/blob/master/company/google/InsertInterval.java
|
MIT
|
public boolean shouldPrintMessage(int timestamp, String message) {
if(messages.containsKey(message)) {
if(timestamp - messages.get(message) >= 10) {
messages.put(message, timestamp);
return true;
} else {
return false;
}
} else {
messages.put(message, timestamp);
return true;
}
}
|
Returns true if the message should be printed in the given timestamp, otherwise returns false.
If this method returns false, the message will not be printed.
The timestamp is in seconds granularity.
|
shouldPrintMessage
|
java
|
kdn251/interviews
|
company/google/LoggerRateLimiter.java
|
https://github.com/kdn251/interviews/blob/master/company/google/LoggerRateLimiter.java
|
MIT
|
public List<Interval> merge(List<Interval> intervals) {
List<Interval> result = new ArrayList<Interval>();
if(intervals == null || intervals.size() == 0) {
return result;
}
Interval[] allIntervals = intervals.toArray(new Interval[intervals.size()]);
Arrays.sort(allIntervals, new Comparator<Interval>() {
public int compare(Interval a, Interval b) {
if(a.start == b.start) {
return a.end - b.end;
}
return a.start - b.start;
}
});
for(Interval i: allIntervals) {
if (result.size() == 0 || result.get(result.size() - 1).end < i.start) {
result.add(i);
} else {
result.get(result.size() - 1).end = Math.max(result.get(result.size() - 1).end, i.end);
}
}
return result;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
merge
|
java
|
kdn251/interviews
|
company/google/MergeIntervals.java
|
https://github.com/kdn251/interviews/blob/master/company/google/MergeIntervals.java
|
MIT
|
public int compare(Interval a, Interval b) {
if(a.start == b.start) {
return a.end - b.end;
}
return a.start - b.start;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
compare
|
java
|
kdn251/interviews
|
company/google/MergeIntervals.java
|
https://github.com/kdn251/interviews/blob/master/company/google/MergeIntervals.java
|
MIT
|
public ListNode plusOne(ListNode head) {
if(plusOneRecursive(head) == 0) {
return head;
} else {
ListNode newHead = new ListNode(1);
newHead.next = head;
return newHead;
}
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
plusOne
|
java
|
kdn251/interviews
|
company/google/PlusOneLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/company/google/PlusOneLinkedList.java
|
MIT
|
private int plusOneRecursive(ListNode head) {
if(head == null) {
return 1;
}
int carry = plusOneRecursive(head.next);
if(carry == 0) {
return 0;
}
int value = head.val + 1;
head.val = value % 10;
return value/10;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
plusOneRecursive
|
java
|
kdn251/interviews
|
company/google/PlusOneLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/company/google/PlusOneLinkedList.java
|
MIT
|
public int next() {
if(i.hasNext()) {
temp = i;
i = j;
j = temp;
}
return j.next();
}
|
Your ZigzagIterator object will be instantiated and called as such:
ZigzagIterator i = new ZigzagIterator(v1, v2);
while (i.hasNext()) v[f()] = i.next();
|
next
|
java
|
kdn251/interviews
|
company/google/ZigZagIterator.java
|
https://github.com/kdn251/interviews/blob/master/company/google/ZigZagIterator.java
|
MIT
|
public boolean hasNext() {
return i.hasNext() || j.hasNext();
}
|
Your ZigzagIterator object will be instantiated and called as such:
ZigzagIterator i = new ZigzagIterator(v1, v2);
while (i.hasNext()) v[f()] = i.next();
|
hasNext
|
java
|
kdn251/interviews
|
company/google/ZigZagIterator.java
|
https://github.com/kdn251/interviews/blob/master/company/google/ZigZagIterator.java
|
MIT
|
public boolean hasNext() {
return stack.isEmpty() ? false : true;
}
|
@return whether we have a next smallest number
|
hasNext
|
java
|
kdn251/interviews
|
company/linkedin/BinarySearchTreeIterator.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/BinarySearchTreeIterator.java
|
MIT
|
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
if(root == null) {
return result;
}
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.add(root);
List<Integer> tempList = new ArrayList<Integer>();
tempList.add(root.val);
result.add(tempList);
while(!queue.isEmpty()) {
Queue<TreeNode> currentLevel = new LinkedList<TreeNode>();
List<Integer> list = new ArrayList<Integer>();
while(!queue.isEmpty()) {
TreeNode current = queue.remove();
if(current.left != null) {
currentLevel.add(current.left);
list.add(current.left.val);
}
if(current.right != null) {
currentLevel.add(current.right);
list.add(current.right.val);
}
}
if(list.size() > 0) {
result.add(list);
}
queue = currentLevel;
}
return result;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
levelOrder
|
java
|
kdn251/interviews
|
company/linkedin/BinaryTreeLevelOrderTraversal.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/BinaryTreeLevelOrderTraversal.java
|
MIT
|
public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
int i = 0;
while(i < intervals.size() && intervals.get(i).end < newInterval.start) {
i++;
}
while(i < intervals.size() && intervals.get(i).start <= newInterval.end) {
newInterval = new Interval(Math.min(intervals.get(i).start, newInterval.start), Math.max(intervals.get(i).end, newInterval.end));
intervals.remove(i);
}
intervals.add(i, newInterval);
return intervals;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
insert
|
java
|
kdn251/interviews
|
company/linkedin/InsertInterval.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/InsertInterval.java
|
MIT
|
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if(root == null || root == p || root == q) {
return root;
}
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p, q);
if(left != null && right != null) {
return root;
}
return left == null ? right : left;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
lowestCommonAncestor
|
java
|
kdn251/interviews
|
company/linkedin/LowestCommonAncestorOfABinaryTree.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/LowestCommonAncestorOfABinaryTree.java
|
MIT
|
public int maxDepth(TreeNode root) {
if(root == null) {
return 0;
}
return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
maxDepth
|
java
|
kdn251/interviews
|
company/linkedin/MaximumDepthOfABinaryTree.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/MaximumDepthOfABinaryTree.java
|
MIT
|
public List<Interval> merge(List<Interval> intervals) {
List<Interval> result = new ArrayList<Interval>();
if(intervals == null || intervals.size() == 0) {
return result;
}
Interval[] allIntervals = intervals.toArray(new Interval[intervals.size()]);
Arrays.sort(allIntervals, new Comparator<Interval>() {
public int compare(Interval a, Interval b) {
if(a.start == b.start) {
return a.end - b.end;
}
return a.start - b.start;
}
});
for(Interval i: allIntervals) {
if (result.size() == 0 || result.get(result.size() - 1).end < i.start) {
result.add(i);
} else {
result.get(result.size() - 1).end = Math.max(result.get(result.size() - 1).end, i.end);
}
}
return result;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
merge
|
java
|
kdn251/interviews
|
company/linkedin/MergeIntervals.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/MergeIntervals.java
|
MIT
|
public int compare(Interval a, Interval b) {
if(a.start == b.start) {
return a.end - b.end;
}
return a.start - b.start;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
compare
|
java
|
kdn251/interviews
|
company/linkedin/MergeIntervals.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/MergeIntervals.java
|
MIT
|
public ListNode mergeKLists(ListNode[] lists) {
if (lists==null||lists.length==0) {
return null;
}
PriorityQueue<ListNode> queue= new PriorityQueue<ListNode>(lists.length,new Comparator<ListNode>(){
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
});
ListNode dummy = new ListNode(0);
ListNode tail=dummy;
for (ListNode node:lists) {
if (node!=null) {
queue.add(node);
}
}
while (!queue.isEmpty()){
tail.next=queue.poll();
tail=tail.next;
if (tail.next!=null) {
queue.add(tail.next);
}
}
return dummy.next;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
mergeKLists
|
java
|
kdn251/interviews
|
company/linkedin/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/MergeKSortedLists.java
|
MIT
|
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
compare
|
java
|
kdn251/interviews
|
company/linkedin/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/MergeKSortedLists.java
|
MIT
|
public boolean isSymmetric(TreeNode root) {
if(root == null) {
return true;
}
return helper(root.left, root.right);
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
isSymmetric
|
java
|
kdn251/interviews
|
company/linkedin/SymmetricTree.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/SymmetricTree.java
|
MIT
|
public boolean helper(TreeNode left, TreeNode right) {
if(left == null && right == null) {
return true;
}
if(left == null || right == null || left.val != right.val) {
return false;
}
return helper(left.right, right.left) && helper(left.left, right.right);
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
helper
|
java
|
kdn251/interviews
|
company/linkedin/SymmetricTree.java
|
https://github.com/kdn251/interviews/blob/master/company/linkedin/SymmetricTree.java
|
MIT
|
public boolean hasCycle(ListNode head) {
if(head == null || head.next == null) {
return false;
}
ListNode slow = head;
ListNode fast = head.next;
while(fast != null && fast.next != null && fast != slow) {
slow = slow.next;
fast = fast.next.next;
}
return fast == slow;
}
|
Definition for singly-linked list.
class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
next = null;
}
}
|
hasCycle
|
java
|
kdn251/interviews
|
company/microsoft/LinkedListCycle.java
|
https://github.com/kdn251/interviews/blob/master/company/microsoft/LinkedListCycle.java
|
MIT
|
@Override
public Integer next() {
return stack.pop().getInteger();
}
|
// This is the interface that allows for creating nested lists.
// You should not implement it, or speculate about its implementation
public interface NestedInteger {
// @return true if this NestedInteger holds a single integer, rather than a nested list.
public boolean isInteger();
// @return the single integer that this NestedInteger holds, if it holds a single integer
// Return null if this NestedInteger holds a nested list
public Integer getInteger();
// @return the nested list that this NestedInteger holds, if it holds a nested list
// Return null if this NestedInteger holds a single integer
public List<NestedInteger> getList();
}
|
next
|
java
|
kdn251/interviews
|
company/twitter/FlattenNestedListIterator.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/FlattenNestedListIterator.java
|
MIT
|
@Override
public boolean hasNext() {
while(!stack.isEmpty()) {
NestedInteger current = stack.peek();
if(current.isInteger()) {
return true;
}
stack.pop();
for(int i = current.getList().size() - 1; i >= 0; i--) {
stack.push(current.getList().get(i));
}
}
return false;
}
|
// This is the interface that allows for creating nested lists.
// You should not implement it, or speculate about its implementation
public interface NestedInteger {
// @return true if this NestedInteger holds a single integer, rather than a nested list.
public boolean isInteger();
// @return the single integer that this NestedInteger holds, if it holds a single integer
// Return null if this NestedInteger holds a nested list
public Integer getInteger();
// @return the nested list that this NestedInteger holds, if it holds a nested list
// Return null if this NestedInteger holds a single integer
public List<NestedInteger> getList();
}
|
hasNext
|
java
|
kdn251/interviews
|
company/twitter/FlattenNestedListIterator.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/FlattenNestedListIterator.java
|
MIT
|
public boolean insert(int val) {
if(!map.containsKey(val)) {
map.put(val, val);
values.add(val);
return true;
}
else {
return false;
}
}
|
Inserts a value to the set. Returns true if the set did not already contain the specified element.
|
insert
|
java
|
kdn251/interviews
|
company/twitter/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/InsertDeleteGetRandomO1.java
|
MIT
|
public boolean remove(int val) {
if(map.containsKey(val)) {
map.remove(val);
values.remove(values.indexOf(val));
return true;
}
return false;
}
|
Removes a value from the set. Returns true if the set contained the specified element.
|
remove
|
java
|
kdn251/interviews
|
company/twitter/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/InsertDeleteGetRandomO1.java
|
MIT
|
public int getRandom() {
int random = (int)(Math.random() * values.size());
int valueToReturn = values.get(random);
return map.get(valueToReturn);
}
|
Get a random element from the set.
|
getRandom
|
java
|
kdn251/interviews
|
company/twitter/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/InsertDeleteGetRandomO1.java
|
MIT
|
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if(root == null || root == p || root == q) {
return root;
}
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p, q);
if(left != null && right != null) {
return root;
}
return left == null ? right : left;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
lowestCommonAncestor
|
java
|
kdn251/interviews
|
company/twitter/LowestCommonAncestorOfABinaryTree.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/LowestCommonAncestorOfABinaryTree.java
|
MIT
|
public List<Interval> merge(List<Interval> intervals) {
List<Interval> result = new ArrayList<Interval>();
if(intervals == null || intervals.size() == 0) {
return result;
}
Interval[] allIntervals = intervals.toArray(new Interval[intervals.size()]);
Arrays.sort(allIntervals, new Comparator<Interval>() {
public int compare(Interval a, Interval b) {
if(a.start == b.start) {
return a.end - b.end;
}
return a.start - b.start;
}
});
for(Interval i: allIntervals) {
if (result.size() == 0 || result.get(result.size() - 1).end < i.start) {
result.add(i);
} else {
result.get(result.size() - 1).end = Math.max(result.get(result.size() - 1).end, i.end);
}
}
return result;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
merge
|
java
|
kdn251/interviews
|
company/twitter/MergeIntervals.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/MergeIntervals.java
|
MIT
|
public int compare(Interval a, Interval b) {
if(a.start == b.start) {
return a.end - b.end;
}
return a.start - b.start;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
compare
|
java
|
kdn251/interviews
|
company/twitter/MergeIntervals.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/MergeIntervals.java
|
MIT
|
public ListNode mergeKLists(ListNode[] lists) {
if (lists==null||lists.length==0) {
return null;
}
PriorityQueue<ListNode> queue= new PriorityQueue<ListNode>(lists.length,new Comparator<ListNode>(){
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
});
ListNode dummy = new ListNode(0);
ListNode tail=dummy;
for (ListNode node:lists) {
if (node!=null) {
queue.add(node);
}
}
while (!queue.isEmpty()){
tail.next=queue.poll();
tail=tail.next;
if (tail.next!=null) {
queue.add(tail.next);
}
}
return dummy.next;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
mergeKLists
|
java
|
kdn251/interviews
|
company/twitter/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/MergeKSortedLists.java
|
MIT
|
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
compare
|
java
|
kdn251/interviews
|
company/twitter/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/MergeKSortedLists.java
|
MIT
|
public ListNode reverseList(ListNode head) {
if(head == null) {
return head;
}
ListNode newHead = null;
while(head != null) {
ListNode next = head.next;
head.next = newHead;
newHead = head;
head = next;
}
return newHead;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
reverseList
|
java
|
kdn251/interviews
|
company/twitter/ReverseLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/company/twitter/ReverseLinkedList.java
|
MIT
|
public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
if(node == null) {
return null;
}
if(map.containsKey(node.label)) {
return map.get(node.label);
}
UndirectedGraphNode newNode = new UndirectedGraphNode(node.label);
map.put(newNode.label, newNode);
for(UndirectedGraphNode neighbor : node.neighbors) {
newNode.neighbors.add(cloneGraph(neighbor));
}
return newNode;
}
|
Definition for undirected graph.
class UndirectedGraphNode {
int label;
List<UndirectedGraphNode> neighbors;
UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
};
|
cloneGraph
|
java
|
kdn251/interviews
|
company/uber/CloneGraph.java
|
https://github.com/kdn251/interviews/blob/master/company/uber/CloneGraph.java
|
MIT
|
public boolean insert(int val) {
if(!map.containsKey(val)) {
map.put(val, val);
values.add(val);
return true;
}
else {
return false;
}
}
|
Inserts a value to the set. Returns true if the set did not already contain the specified element.
|
insert
|
java
|
kdn251/interviews
|
company/uber/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/uber/InsertDeleteGetRandomO1.java
|
MIT
|
public boolean remove(int val) {
if(map.containsKey(val)) {
map.remove(val);
values.remove(values.indexOf(val));
return true;
}
return false;
}
|
Removes a value from the set. Returns true if the set contained the specified element.
|
remove
|
java
|
kdn251/interviews
|
company/uber/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/uber/InsertDeleteGetRandomO1.java
|
MIT
|
public int getRandom() {
int random = (int)(Math.random() * values.size());
int valueToReturn = values.get(random);
return map.get(valueToReturn);
}
|
Get a random element from the set.
|
getRandom
|
java
|
kdn251/interviews
|
company/uber/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/uber/InsertDeleteGetRandomO1.java
|
MIT
|
public int maxDepth(TreeNode root) {
if(root == null) {
return 0;
}
return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
maxDepth
|
java
|
kdn251/interviews
|
company/uber/MaximumDepthOfABinaryTree.java
|
https://github.com/kdn251/interviews/blob/master/company/uber/MaximumDepthOfABinaryTree.java
|
MIT
|
public ListNode mergeKLists(ListNode[] lists) {
if (lists==null||lists.length==0) {
return null;
}
PriorityQueue<ListNode> queue= new PriorityQueue<ListNode>(lists.length,new Comparator<ListNode>(){
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
});
ListNode dummy = new ListNode(0);
ListNode tail=dummy;
for (ListNode node:lists) {
if (node!=null) {
queue.add(node);
}
}
while (!queue.isEmpty()){
tail.next=queue.poll();
tail=tail.next;
if (tail.next!=null) {
queue.add(tail.next);
}
}
return dummy.next;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
mergeKLists
|
java
|
kdn251/interviews
|
company/uber/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/company/uber/MergeKSortedLists.java
|
MIT
|
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
compare
|
java
|
kdn251/interviews
|
company/uber/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/company/uber/MergeKSortedLists.java
|
MIT
|
public ListNode reverseList(ListNode head) {
if(head == null) {
return head;
}
ListNode newHead = null;
while(head != null) {
ListNode next = head.next;
head.next = newHead;
newHead = head;
head = next;
}
return newHead;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
reverseList
|
java
|
kdn251/interviews
|
company/uber/ReverseLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/company/uber/ReverseLinkedList.java
|
MIT
|
public boolean hasCycle(ListNode head) {
if(head == null || head.next == null) {
return false;
}
ListNode slow = head;
ListNode fast = head.next;
while(fast != null && fast.next != null && fast != slow) {
slow = slow.next;
fast = fast.next.next;
}
return fast == slow;
}
|
Definition for singly-linked list.
class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
next = null;
}
}
|
hasCycle
|
java
|
kdn251/interviews
|
company/yahoo/LinkedListCycle.java
|
https://github.com/kdn251/interviews/blob/master/company/yahoo/LinkedListCycle.java
|
MIT
|
public boolean insert(int val) {
if(!map.containsKey(val)) {
map.put(val, val);
values.add(val);
return true;
}
else {
return false;
}
}
|
Inserts a value to the set. Returns true if the set did not already contain the specified element.
|
insert
|
java
|
kdn251/interviews
|
company/yelp/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/yelp/InsertDeleteGetRandomO1.java
|
MIT
|
public boolean remove(int val) {
if(map.containsKey(val)) {
map.remove(val);
values.remove(values.indexOf(val));
return true;
}
return false;
}
|
Removes a value from the set. Returns true if the set contained the specified element.
|
remove
|
java
|
kdn251/interviews
|
company/yelp/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/yelp/InsertDeleteGetRandomO1.java
|
MIT
|
public int getRandom() {
int random = (int)(Math.random() * values.size());
int valueToReturn = values.get(random);
return map.get(valueToReturn);
}
|
Get a random element from the set.
|
getRandom
|
java
|
kdn251/interviews
|
company/yelp/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/company/yelp/InsertDeleteGetRandomO1.java
|
MIT
|
public boolean insert(int val) {
if(!map.containsKey(val)) {
map.put(val, val);
values.add(val);
return true;
}
else {
return false;
}
}
|
Inserts a value to the set. Returns true if the set did not already contain the specified element.
|
insert
|
java
|
kdn251/interviews
|
leetcode/array/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/array/InsertDeleteGetRandomO1.java
|
MIT
|
public boolean remove(int val) {
if(map.containsKey(val)) {
map.remove(val);
values.remove(values.indexOf(val));
return true;
}
return false;
}
|
Removes a value from the set. Returns true if the set contained the specified element.
|
remove
|
java
|
kdn251/interviews
|
leetcode/array/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/array/InsertDeleteGetRandomO1.java
|
MIT
|
public int getRandom() {
int random = (int)(Math.random() * values.size());
int valueToReturn = values.get(random);
return map.get(valueToReturn);
}
|
Get a random element from the set.
|
getRandom
|
java
|
kdn251/interviews
|
leetcode/array/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/array/InsertDeleteGetRandomO1.java
|
MIT
|
public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
int i = 0;
while(i < intervals.size() && intervals.get(i).end < newInterval.start) {
i++;
}
while(i < intervals.size() && intervals.get(i).start <= newInterval.end) {
newInterval = new Interval(Math.min(intervals.get(i).start, newInterval.start), Math.max(intervals.get(i).end, newInterval.end));
intervals.remove(i);
}
intervals.add(i, newInterval);
return intervals;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
insert
|
java
|
kdn251/interviews
|
leetcode/array/InsertInterval.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/array/InsertInterval.java
|
MIT
|
public List<Interval> merge(List<Interval> intervals) {
List<Interval> result = new ArrayList<Interval>();
if(intervals == null || intervals.size() == 0) {
return result;
}
Interval[] allIntervals = intervals.toArray(new Interval[intervals.size()]);
Arrays.sort(allIntervals, new Comparator<Interval>() {
public int compare(Interval a, Interval b) {
if(a.start == b.start) {
return a.end - b.end;
}
return a.start - b.start;
}
});
for(Interval i: allIntervals) {
if (result.size() == 0 || result.get(result.size() - 1).end < i.start) {
result.add(i);
} else {
result.get(result.size() - 1).end = Math.max(result.get(result.size() - 1).end, i.end);
}
}
return result;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
merge
|
java
|
kdn251/interviews
|
leetcode/array/MergeIntervals.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/array/MergeIntervals.java
|
MIT
|
public int compare(Interval a, Interval b) {
if(a.start == b.start) {
return a.end - b.end;
}
return a.start - b.start;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
compare
|
java
|
kdn251/interviews
|
leetcode/array/MergeIntervals.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/array/MergeIntervals.java
|
MIT
|
public int closestValue(TreeNode root, double target) {
int value = root.val;
TreeNode child = root.val < target ? root.right : root.left;
if(child == null) {
return value;
}
int childValue = closestValue(child, target);
return Math.abs(value - target) < Math.abs(childValue - target) ? value : childValue;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
closestValue
|
java
|
kdn251/interviews
|
leetcode/binary-search/ClosestBinarySearchTreeValue.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/binary-search/ClosestBinarySearchTreeValue.java
|
MIT
|
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
if(root == null) {
return result;
}
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.add(root);
List<Integer> tempList = new ArrayList<Integer>();
tempList.add(root.val);
result.add(tempList);
while(!queue.isEmpty()) {
Queue<TreeNode> currentLevel = new LinkedList<TreeNode>();
List<Integer> list = new ArrayList<Integer>();
while(!queue.isEmpty()) {
TreeNode current = queue.remove();
if(current.left != null) {
currentLevel.add(current.left);
list.add(current.left.val);
}
if(current.right != null) {
currentLevel.add(current.right);
list.add(current.right.val);
}
}
if(list.size() > 0) {
result.add(list);
}
queue = currentLevel;
}
return result;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
levelOrder
|
java
|
kdn251/interviews
|
leetcode/breadth-first-search/BinaryTreeLevelOrderTraversal.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/breadth-first-search/BinaryTreeLevelOrderTraversal.java
|
MIT
|
public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
if(node == null) {
return null;
}
if(map.containsKey(node.label)) {
return map.get(node.label);
}
UndirectedGraphNode newNode = new UndirectedGraphNode(node.label);
map.put(newNode.label, newNode);
for(UndirectedGraphNode neighbor : node.neighbors) {
newNode.neighbors.add(cloneGraph(neighbor));
}
return newNode;
}
|
Definition for undirected graph.
class UndirectedGraphNode {
int label;
List<UndirectedGraphNode> neighbors;
UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
};
|
cloneGraph
|
java
|
kdn251/interviews
|
leetcode/breadth-first-search/CloneGraph.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/breadth-first-search/CloneGraph.java
|
MIT
|
public boolean isSymmetric(TreeNode root) {
if(root == null) {
return true;
}
return helper(root.left, root.right);
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
isSymmetric
|
java
|
kdn251/interviews
|
leetcode/breadth-first-search/SymmetricTree.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/breadth-first-search/SymmetricTree.java
|
MIT
|
public boolean helper(TreeNode left, TreeNode right) {
if(left == null && right == null) {
return true;
}
if(left == null || right == null || left.val != right.val) {
return false;
}
return helper(left.right, right.left) && helper(left.left, right.right);
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
helper
|
java
|
kdn251/interviews
|
leetcode/breadth-first-search/SymmetricTree.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/breadth-first-search/SymmetricTree.java
|
MIT
|
public boolean isBalanced(TreeNode root) {
height(root);
return balanced;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
isBalanced
|
java
|
kdn251/interviews
|
leetcode/depth-first-search/BalancedBinaryTree.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/depth-first-search/BalancedBinaryTree.java
|
MIT
|
private int height(TreeNode root) {
if(root == null) {
return 0;
}
int leftHeight = height(root.left);
int rightHeight = height(root.right);
if(Math.abs(leftHeight - rightHeight) > 1) {
balanced = false;
}
return 1 + Math.max(leftHeight, rightHeight);
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
height
|
java
|
kdn251/interviews
|
leetcode/depth-first-search/BalancedBinaryTree.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/depth-first-search/BalancedBinaryTree.java
|
MIT
|
public TreeNode sortedArrayToBST(int[] nums) {
if(nums.length == 0) {
return null;
}
TreeNode root = helper(nums, 0, nums.length - 1);
return root;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
sortedArrayToBST
|
java
|
kdn251/interviews
|
leetcode/depth-first-search/ConvertSortedArrayToBinarySearchTree.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/depth-first-search/ConvertSortedArrayToBinarySearchTree.java
|
MIT
|
private TreeNode helper(int[] nums, int start, int end) {
if(start <= end) {
int mid = (start + end) / 2;
TreeNode current = new TreeNode(nums[mid]);
current.left = helper(nums, start, mid - 1);
current.right = helper(nums, mid + 1, end);
return current;
}
return null;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
helper
|
java
|
kdn251/interviews
|
leetcode/depth-first-search/ConvertSortedArrayToBinarySearchTree.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/depth-first-search/ConvertSortedArrayToBinarySearchTree.java
|
MIT
|
public int maxDepth(TreeNode root) {
if(root == null) {
return 0;
}
return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
maxDepth
|
java
|
kdn251/interviews
|
leetcode/depth-first-search/MaximumDepthOfABinaryTree.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/depth-first-search/MaximumDepthOfABinaryTree.java
|
MIT
|
public void connect(TreeLinkNode root) {
if(root == null) {
return;
}
Queue<TreeLinkNode> queue = new LinkedList<TreeLinkNode>();
queue.add(root);
while(!queue.isEmpty()) {
Queue<TreeLinkNode> currentLevel = new LinkedList<TreeLinkNode>();
TreeLinkNode temp = null;
while(!queue.isEmpty()) {
TreeLinkNode current = queue.remove();
current.next = temp;
temp = current;
if(current.right != null) {
currentLevel.add(current.right);
}
if(current.left!= null) {
currentLevel.add(current.left);
}
}
queue = currentLevel;
}
}
|
Definition for binary tree with next pointer.
public class TreeLinkNode {
int val;
TreeLinkNode left, right, next;
TreeLinkNode(int x) { val = x; }
}
|
connect
|
java
|
kdn251/interviews
|
leetcode/depth-first-search/PopulatingNextRightPointersInEachNode.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/depth-first-search/PopulatingNextRightPointersInEachNode.java
|
MIT
|
public boolean isSameTree(TreeNode p, TreeNode q) {
if(p == null && q == null) {
return true;
}
if(p == null && q != null || q == null && p != null) {
return false;
}
if(p.val != q.val) {
return false;
}
return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
isSameTree
|
java
|
kdn251/interviews
|
leetcode/depth-first-search/SameTree.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/depth-first-search/SameTree.java
|
MIT
|
public boolean insert(int val) {
if(!map.containsKey(val)) {
map.put(val, val);
values.add(val);
return true;
}
else {
return false;
}
}
|
Inserts a value to the set. Returns true if the set did not already contain the specified element.
|
insert
|
java
|
kdn251/interviews
|
leetcode/design/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/design/InsertDeleteGetRandomO1.java
|
MIT
|
public boolean remove(int val) {
if(map.containsKey(val)) {
map.remove(val);
values.remove(values.indexOf(val));
return true;
}
return false;
}
|
Removes a value from the set. Returns true if the set contained the specified element.
|
remove
|
java
|
kdn251/interviews
|
leetcode/design/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/design/InsertDeleteGetRandomO1.java
|
MIT
|
public int getRandom() {
int random = (int)(Math.random() * values.size());
int valueToReturn = values.get(random);
return map.get(valueToReturn);
}
|
Get a random element from the set.
|
getRandom
|
java
|
kdn251/interviews
|
leetcode/design/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/design/InsertDeleteGetRandomO1.java
|
MIT
|
public int next() {
if(i.hasNext()) {
temp = i;
i = j;
j = temp;
}
return j.next();
}
|
Your ZigzagIterator object will be instantiated and called as such:
ZigzagIterator i = new ZigzagIterator(v1, v2);
while (i.hasNext()) v[f()] = i.next();
|
next
|
java
|
kdn251/interviews
|
leetcode/design/ZigZagIterator.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/design/ZigZagIterator.java
|
MIT
|
public boolean hasNext() {
return i.hasNext() || j.hasNext();
}
|
Your ZigzagIterator object will be instantiated and called as such:
ZigzagIterator i = new ZigzagIterator(v1, v2);
while (i.hasNext()) v[f()] = i.next();
|
hasNext
|
java
|
kdn251/interviews
|
leetcode/design/ZigZagIterator.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/design/ZigZagIterator.java
|
MIT
|
public List<List<Integer>> verticalOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
if(root == null) {
return result;
}
Map<Integer, ArrayList<Integer>> map = new HashMap<>();
Queue<TreeNode> q = new LinkedList<>();
Queue<Integer> cols = new LinkedList<>();
q.add(root);
cols.add(0);
int min = 0;
int max = 0;
while(!q.isEmpty()) {
TreeNode node = q.poll();
int col = cols.poll();
if(!map.containsKey(col)) {
map.put(col, new ArrayList<Integer>());
}
map.get(col).add(node.val);
if(node.left != null) {
q.add(node.left);
cols.add(col - 1);
min = Math.min(min, col - 1);
}
if(node.right != null) {
q.add(node.right);
cols.add(col + 1);
max = Math.max(max, col + 1);
}
}
for(int i = min; i <= max; i++) {
result.add(map.get(i));
}
return result;
}
|
Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
|
verticalOrder
|
java
|
kdn251/interviews
|
leetcode/hash-table/BinaryTreeVerticalOrderTraversal.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/hash-table/BinaryTreeVerticalOrderTraversal.java
|
MIT
|
public boolean insert(int val) {
if(!map.containsKey(val)) {
map.put(val, val);
values.add(val);
return true;
}
else {
return false;
}
}
|
Inserts a value to the set. Returns true if the set did not already contain the specified element.
|
insert
|
java
|
kdn251/interviews
|
leetcode/hash-table/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/hash-table/InsertDeleteGetRandomO1.java
|
MIT
|
public boolean remove(int val) {
if(map.containsKey(val)) {
map.remove(val);
values.remove(values.indexOf(val));
return true;
}
return false;
}
|
Removes a value from the set. Returns true if the set contained the specified element.
|
remove
|
java
|
kdn251/interviews
|
leetcode/hash-table/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/hash-table/InsertDeleteGetRandomO1.java
|
MIT
|
public int getRandom() {
int random = (int)(Math.random() * values.size());
int valueToReturn = values.get(random);
return map.get(valueToReturn);
}
|
Get a random element from the set.
|
getRandom
|
java
|
kdn251/interviews
|
leetcode/hash-table/InsertDeleteGetRandomO1.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/hash-table/InsertDeleteGetRandomO1.java
|
MIT
|
public boolean shouldPrintMessage(int timestamp, String message) {
if(messages.containsKey(message)) {
if(timestamp - messages.get(message) >= 10) {
messages.put(message, timestamp);
return true;
} else {
return false;
}
} else {
messages.put(message, timestamp);
return true;
}
}
|
Returns true if the message should be printed in the given timestamp, otherwise returns false.
If this method returns false, the message will not be printed.
The timestamp is in seconds granularity.
|
shouldPrintMessage
|
java
|
kdn251/interviews
|
leetcode/hash-table/LoggerRateLimiter.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/hash-table/LoggerRateLimiter.java
|
MIT
|
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode current1 = l1;
ListNode current2 = l2;
ListNode head = new ListNode(0);
ListNode currentHead = head;
int sum = 0;
while(current1 != null || current2 != null) {
sum /= 10;
if(current1 != null) {
sum += current1.val;
current1 = current1.next;
}
if(current2 != null) {
sum += current2.val;
current2 = current2.next;
}
currentHead.next = new ListNode(sum % 10);
currentHead = currentHead.next;
}
if(sum / 10 == 1) {
currentHead.next = new ListNode(1);
}
return head.next;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
addTwoNumbers
|
java
|
kdn251/interviews
|
leetcode/linked-list/AddTwoNumbers.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/linked-list/AddTwoNumbers.java
|
MIT
|
public void deleteNode(ListNode node) {
node.val = node.next.val;
node.next = node.next.next;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
deleteNode
|
java
|
kdn251/interviews
|
leetcode/linked-list/DeleteNodeInALinkedList.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/linked-list/DeleteNodeInALinkedList.java
|
MIT
|
public boolean hasCycle(ListNode head) {
if(head == null || head.next == null) {
return false;
}
ListNode slow = head;
ListNode fast = head.next;
while(fast != null && fast.next != null && fast != slow) {
slow = slow.next;
fast = fast.next.next;
}
return fast == slow;
}
|
Definition for singly-linked list.
class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
next = null;
}
}
|
hasCycle
|
java
|
kdn251/interviews
|
leetcode/linked-list/LinkedListCycle.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/linked-list/LinkedListCycle.java
|
MIT
|
public ListNode mergeKLists(ListNode[] lists) {
if (lists==null||lists.length==0) {
return null;
}
PriorityQueue<ListNode> queue= new PriorityQueue<ListNode>(lists.length,new Comparator<ListNode>(){
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
});
ListNode dummy = new ListNode(0);
ListNode tail=dummy;
for (ListNode node:lists) {
if (node!=null) {
queue.add(node);
}
}
while (!queue.isEmpty()){
tail.next=queue.poll();
tail=tail.next;
if (tail.next!=null) {
queue.add(tail.next);
}
}
return dummy.next;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
mergeKLists
|
java
|
kdn251/interviews
|
leetcode/linked-list/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/linked-list/MergeKSortedLists.java
|
MIT
|
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val) {
return -1;
} else if (o1.val==o2.val) {
return 0;
} else {
return 1;
}
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
compare
|
java
|
kdn251/interviews
|
leetcode/linked-list/MergeKSortedLists.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/linked-list/MergeKSortedLists.java
|
MIT
|
public boolean isPalindrome(ListNode head) {
if(head == null || head.next == null) {
return true;
}
Stack<Integer> stack = new Stack<Integer>();
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null) {
stack.push(slow.val);
fast = fast.next.next;
slow = slow.next;
}
if(fast != null) {
slow = slow.next;
}
while(slow != null) {
if(stack.pop() != slow.val) {
return false;
}
slow = slow.next;
}
return true;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
isPalindrome
|
java
|
kdn251/interviews
|
leetcode/linked-list/PalindromeLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/linked-list/PalindromeLinkedList.java
|
MIT
|
public ListNode plusOne(ListNode head) {
if(plusOneRecursive(head) == 0) {
return head;
} else {
ListNode newHead = new ListNode(1);
newHead.next = head;
return newHead;
}
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
plusOne
|
java
|
kdn251/interviews
|
leetcode/linked-list/PlusOneLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/linked-list/PlusOneLinkedList.java
|
MIT
|
private int plusOneRecursive(ListNode head) {
if(head == null) {
return 1;
}
int carry = plusOneRecursive(head.next);
if(carry == 0) {
return 0;
}
int value = head.val + 1;
head.val = value % 10;
return value/10;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
plusOneRecursive
|
java
|
kdn251/interviews
|
leetcode/linked-list/PlusOneLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/linked-list/PlusOneLinkedList.java
|
MIT
|
public ListNode reverseList(ListNode head) {
if(head == null) {
return head;
}
ListNode newHead = null;
while(head != null) {
ListNode next = head.next;
head.next = newHead;
newHead = head;
head = next;
}
return newHead;
}
|
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
|
reverseList
|
java
|
kdn251/interviews
|
leetcode/linked-list/ReverseLinkedList.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/linked-list/ReverseLinkedList.java
|
MIT
|
public boolean canAttendMeetings(Interval[] intervals) {
if(intervals == null) {
return false;
}
// Sort the intervals by start time
Arrays.sort(intervals, new Comparator<Interval>() {
public int compare(Interval a, Interval b) { return a.start - b.start; }
});
for(int i = 1; i < intervals.length; i++) {
if(intervals[i].start < intervals[i - 1].end) {
return false;
}
}
return true;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
canAttendMeetings
|
java
|
kdn251/interviews
|
leetcode/sort/MeetingRooms.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/sort/MeetingRooms.java
|
MIT
|
public int minMeetingRooms(Interval[] intervals) {
int[] starts = new int[intervals.length];
int[] ends = new int[intervals.length];
for(int i=0; i<intervals.length; i++) {
starts[i] = intervals[i].start;
ends[i] = intervals[i].end;
}
Arrays.sort(starts);
Arrays.sort(ends);
int rooms = 0;
int endsItr = 0;
for(int i=0; i<starts.length; i++) {
if(starts[i]<ends[endsItr]) {
rooms++;
} else {
endsItr++;
}
}
return rooms;
}
|
Definition for an interval.
public class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
|
minMeetingRooms
|
java
|
kdn251/interviews
|
leetcode/sort/MeetingRoomsII.java
|
https://github.com/kdn251/interviews/blob/master/leetcode/sort/MeetingRoomsII.java
|
MIT
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.