Add solutions

Author: andrewbayd

src/com/andrewbayd/deleteNodeInLinkedList/Solution.java renamed to src/com/andrewbayd/DeleteNodeInLinkedList.java

@@ -1,4 +1,4 @@
-package com.andrewbayd.deleteNodeInLinkedList;
+package com.andrewbayd;
 
 /*
 Write a function to delete a node in a singly-linked list. You will not be given access to the head of the list, instead you will be given access to the node to be deleted directly.
@@ -7,7 +7,9 @@
 https://leetcode.com/problems/delete-node-in-a-linked-list/
  */
 
-public class Solution {
+import com.andrewbayd.datastructures.ListNode;
+
+public class DeleteNodeInLinkedList {
     public void deleteNode(ListNode node) {
         node.val = node.next.val;
         node.next = node.next.next;

src/com/andrewbayd/mergeTwoSortedLists/MergeTwoSortedLists.java renamed to src/com/andrewbayd/MergeTwoSortedLists.java

@@ -1,4 +1,6 @@
-package com.andrewbayd.mergeTwoSortedLists;
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.ListNode;
 
 public class MergeTwoSortedLists {
     public static ListNode mergeTwoLists(ListNode list1, ListNode list2) {

src/com/andrewbayd/PalindromeLinkedList.java

@@ -0,0 +1,48 @@
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.ListNode;
+
+/*
+Given the head of a singly linked list, return true if it is a palindrome.
+
+https://leetcode.com/problems/palindrome-linked-list/
+ */
+
+public class PalindromeLinkedList {
+    public boolean isPalindrome(ListNode head) {
+        if (head == null || head.next == null) {
+            return true;
+        }
+        // Find a middle point of a list using two pointers
+        ListNode fast = head;
+        ListNode slow = head;
+        while (fast != null && fast.next != null) {
+            fast = fast.next.next;
+            slow = slow.next;
+        }
+        // Reverse first half of a list
+        ListNode rev = head;
+        ListNode curr = head.next;
+        rev.next = null;
+        while (curr != slow) {
+            ListNode next = curr.next;
+            curr.next = rev;
+            rev = curr;
+            curr = next;
+        }
+        // If list has an odd number of nodes move slow pointer one node forward
+        if (fast != null) {
+            slow = slow.next;
+        }
+        // Compare lists
+        while (slow != null) {
+            if (slow.val != rev.val) {
+                return false;
+            }
+            slow = slow.next;
+            rev = rev.next;
+        }
+
+        return true;
+    }
+}

src/com/andrewbayd/ReverseLinkedList.java

@@ -0,0 +1,30 @@
+package com.andrewbayd;
+
+/*
+Given the head of a singly linked list, reverse the list, and return the reversed list.
+
+https://leetcode.com/problems/reverse-linked-list/
+ */
+
+import com.andrewbayd.datastructures.ListNode;
+
+public class ReverseLinkedList {
+    public ListNode reverseList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+
+        ListNode prev = head;
+        ListNode curr = head.next;
+        prev.next = null;
+
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+
+        return prev;
+    }
+}

src/com/andrewbayd/SearchInsertPosition.java

@@ -0,0 +1,31 @@
+package com.andrewbayd;
+
+/*
+Given a sorted array of distinct integers and a target value, return the index if the target is found.
+If not, return the index where it would be if it were inserted in order.
+
+https://leetcode.com/problems/search-insert-position/
+ */
+
+public class SearchInsertPosition {
+    public static int searchInsert(int[] nums, int target) {
+        int first = 0;
+        int last = nums.length - 1;
+        int mid = -1;
+        while (first <= last) {
+            mid = first + (last - first) / 2;
+            if (nums[mid] == target) return mid;
+            else if (nums[mid] > target) last = mid - 1;
+            else first = mid + 1;
+        }
+        if (nums[mid] < target) return mid + 1;
+        else return mid;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(searchInsert(new int[]{1,3}, 2)); //-> 1
+        System.out.println(searchInsert(new int[]{1,3,5,6}, 5)); //-> 2
+        System.out.println(searchInsert(new int[]{1,3,5,6}, 2)); //-> 1
+        System.out.println(searchInsert(new int[]{1,3,5,6}, 7)); //-> 4
+    }
+}

src/com/andrewbayd/SearchRotatedSortedArray.java

@@ -0,0 +1,41 @@
+package com.andrewbayd;
+
+/*
+Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.
+
+https://leetcode.com/problems/search-in-rotated-sorted-array/
+ */
+
+public class SearchRotatedSortedArray {
+    public static int search(int[] nums, int target) {
+        int first = 0;
+        int last = nums.length - 1;
+
+        while (first <= last) {
+            int mid = first + (last - first) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            }
+            if (nums[first] <= nums[mid]) {
+                if (target >= nums[first] && target < nums[mid]) {
+                    last = mid - 1;
+                } else {
+                    first = mid + 1;
+                }
+            } else {
+                if (target > nums[mid] && target <= nums[last]) {
+                    first = mid + 1;
+                } else {
+                    last = mid - 1;
+                }
+            }
+        }
+
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(search(new int[]{4, 5, 6, 7, 0, 1, 2}, 0)); //-> 4
+        System.out.println(search(new int[]{4, 5, 6, 7, 0, 1, 2}, 3)); //-> -1
+    }
+}

src/com/andrewbayd/TwoSumII.java

@@ -0,0 +1,31 @@
+package com.andrewbayd;
+
+/*
+Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number.
+Let these two numbers be numbers[index1] and numbers[index2] where 1 <= index1 < index2 <= numbers.length.
+Return the indices of the two numbers, index1 and index2, added by one as an integer array [index1, index2] of length 2.
+
+https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/
+ */
+
+import java.util.Arrays;
+
+public class TwoSumII {
+    public static int[] twoSum(int[] numbers, int target) {
+        int first = 0;
+        int last = numbers.length - 1;
+        while (first < last) {
+            if (numbers[first] + numbers[last] == target) return new int[]{first + 1, last + 1};
+            else if (numbers[first] + numbers[last] < target) first++;
+            else last--;
+        }
+        return new int[]{};
+    }
+
+    public static void main(String[] args) {
+        int[] result1 = twoSum(new int[]{2, 7, 11, 15}, 9);
+        int[] result2 = twoSum(new int[]{1, 2, 5, 6, 7, 9}, 9);
+        System.out.println(Arrays.toString(result1)); //-> [1, 2]
+        System.out.println(Arrays.toString(result2)); //-> [2, 5]
+    }
+}

src/com/andrewbayd/ValidPerfectSquare.java

@@ -0,0 +1,26 @@
+package com.andrewbayd;
+
+/*
+Given a positive integer num, write a function which returns True if num is a perfect square else False.
+
+https://leetcode.com/problems/valid-perfect-square/
+ */
+
+public class ValidPerfectSquare {
+    public static boolean isPerfectSquare(int num) {
+        long first = 1;
+        long last = num;
+        while (first <= last) {
+            long mid = first + (last - first) / 2;
+            if (mid * mid == (long)num) return true;
+            if (mid * mid > (long)num ) last = mid - 1;
+            else first = mid + 1;
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(isPerfectSquare(16)); //-> true
+        System.out.println(isPerfectSquare(14)); //-> false
+    }
+}

src/com/andrewbayd/BinarySearchTreeLCA/Solution.java renamed to src/com/andrewbayd/binarySearchTreeLCA/Solution.java

@@ -1,4 +1,4 @@
-package com.andrewbayd.BinarySearchTreeLCA;
+package com.andrewbayd.binarySearchTreeLCA;
 
 /*
 Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

src/com/andrewbayd/BinarySearchTreeLCA/TreeNode.java renamed to src/com/andrewbayd/binarySearchTreeLCA/TreeNode.java

@@ -1,4 +1,4 @@
-package com.andrewbayd.BinarySearchTreeLCA;
+package com.andrewbayd.binarySearchTreeLCA;
 
 public class TreeNode {
     int val;

src/com/andrewbayd/datastructures/ListNode.java

@@ -0,0 +1,18 @@
+package com.andrewbayd.datastructures;
+
+public class ListNode {
+    public int val;
+   public ListNode next;
+
+    public ListNode() {
+    }
+
+    public ListNode(int val) {
+        this.val = val;
+    }
+
+    public ListNode(int val, ListNode next) {
+        this.val = val;
+        this.next = next;
+    }
+}

src/com/andrewbayd/deleteNodeInLinkedList/ListNode.java

@@ -0,0 +1,58 @@
+package com.andrewbayd.symmetricTree;
+
+/*
+Given the root of a binary tree, check whether it is a mirror of itself (i.e., symmetric around its center).
+
+https://leetcode.com/problems/symmetric-tree/
+ */
+
+public class Solution {
+    public boolean isSymmetric(TreeNode root) {
+        return isSymetricRecursive(root.left, root.right);
+    }
+
+    private boolean isSymetricRecursive(TreeNode first, TreeNode second) {
+        if (first == null && second == null) {
+            return true;
+        }
+        if (first == null || second == null || first.val != second.val) {
+            return false;
+        }
+        return isSymetricRecursive(first.left, second.right) && isSymetricRecursive(first.right, second.left);
+    }
+
+    /*
+    Iterative solution
+
+    public boolean isSymmetric(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root.left);
+        queue.add(root.right);
+
+        while (!queue.isEmpty()) {
+            TreeNode first = queue.remove();
+            TreeNode second = queue.remove();
+
+            if (first == null && second == null) {
+                continue;
+            }
+
+            if ((first == null && second != null) || (first != null && second == null) || first.val != second.val) {
+                return false;
+            }
+
+            queue.add(first.left);
+            queue.add(second.right);
+            queue.add(first.right);
+            queue.add(second.left);
+        }
+
+        return true;
+    }
+    */
+
+}

src/com/andrewbayd/mergeTwoSortedLists/ListNode.java

@@ -0,0 +1,20 @@
+package com.andrewbayd.symmetricTree;
+
+public class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode() {
+    }
+
+    TreeNode(int val) {
+        this.val = val;
+    }
+
+    TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}