binary search

Author: genkimaru

src/main/java/com/leetcode/binarysearch/BinarySearch.java

@@ -0,0 +1,32 @@
+package com.leetcode.binarysearch;
+
+public class BinarySearch {
+
+
+    public int searchInsert(int[] arr , int target){
+        int left = 0 , right = arr.length -1 ;
+        while(left <= right){
+
+            int mid = ( left + right ) / 2;
+            if(arr[mid] == target){
+                return mid;
+            }else if(target < arr[mid]){
+               right = mid -  1;
+            }else{
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    public static void main(String[] args) {
+
+        int[] nums = {1,3,5,7 ,9};
+        int target = 6;
+
+        int index = new BinarySearch().searchInsert(nums , target);
+        System.out.println(index);
+
+
+    }
+}

src/main/java/com/leetcode/binarysearch/SearchMatrix.java

@@ -0,0 +1,61 @@
+package com.leetcode.binarysearch;
+
+
+/**
+ *     Search a 2D Matrix
+ */
+public class SearchMatrix {
+
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int rows = matrix.length;
+        int columns = matrix[0].length;
+        int targetRow = searchRow(matrix, target, rows, columns);
+        if(targetRow == -1 ){
+            return true;
+        }else if(targetRow >= rows){
+            return false;
+        } else{
+            return searchTarget(matrix[targetRow] , target);
+        }
+    }
+
+    private boolean searchTarget(int[] arr, int target) {
+        int left = 0 , right = arr.length -1 ;
+        while(left <= right){
+
+            int mid = ( left + right ) / 2;
+            if(arr[mid] == target){
+                return true;
+            }else if(target < arr[mid]){
+                right = mid -  1;
+            }else{
+                left = mid + 1;
+            }
+        }
+        return false;
+    }
+
+    private  int  searchRow(int[][] matrix, int target, int rows, int columns) {
+        int left = 0 , right = rows -1;
+        while(left <= right){
+            int mid = (left + right) / 2;
+            // if can search directly in the row end number, pass -1 to identify it can be searched.
+            if(target == matrix[mid][columns - 1] ){
+                return -1;
+            }
+            else if(target > matrix[mid][columns - 1]  ){
+                left = mid + 1;
+            }else{
+                right = mid -1;
+            }
+        }
+        return left;
+    }
+
+    public static void main(String[] args) {
+        int[][] matrix = {{1,3,5,7},{10,11,16,20},{23,30,34,60}};
+        int target = 2;
+        boolean b = new SearchMatrix().searchMatrix(matrix, target);
+        System.out.println(b);
+    }
+}

src/main/java/com/leetcode/dynamicplan/BestTIme.java

@@ -0,0 +1,32 @@
+package com.leetcode.dynamicplan;
+
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Optional;
+
+/**
+ *
+ * Best Time to Buy and Sell Stock
+ */
+
+public class BestTIme {
+
+    private int minPrice = Integer.MAX_VALUE;
+    private int maxprofit = Integer.MIN_VALUE;
+
+    public int maxProfit(int[] prices) {
+        for(int price : prices){
+            minPrice = Math.min(minPrice , price);
+            maxprofit = Math.max(maxprofit , price - minPrice);
+        }
+        return maxprofit;
+    }
+
+    public static void main(String[] args) {
+        BestTIme bestTIme = new BestTIme();
+        int[] prices = {7,1,5,3,6,4};
+        int maxProfit = bestTIme.maxProfit(prices);
+        System.out.println(maxProfit);
+    }
+}

src/main/java/com/leetcode/recursion/RecursionOne.java renamed to src/main/java/com/leetcode/recursion/Permutate.java

@@ -7,7 +7,7 @@
 /**
  * permutation or  arrangement problem: [1,2,3] => [1,2,3] [1,3,2] ,[2,1,3] ,[2,3,1],[3,1,2],[3,2,1]
  */
-public class RecursionOne {
+public class Permutate {
 
     private int count;
     private ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
@@ -57,7 +57,7 @@ public int[] restOfArr(int ele, int[] arr) {
 
     public static void main(String[] args) {
         int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
-        RecursionOne arrangement = new RecursionOne();
+        Permutate arrangement = new Permutate();
         arrangement.arrange(arr);
         arrangement.result.stream().forEach(new Consumer<ArrayList<Integer>>() {
             @Override

src/main/java/com/leetcode/recursion/RecursionOneS.java renamed to src/main/java/com/leetcode/recursion/PermutateS.java

@@ -3,12 +3,12 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public class RecursionOneS {
+public class PermutateS {
 
 
     public static void main(String[] args) {
         String s = "abc";
-        RecursionOneS recursionOneS = new RecursionOneS();
+        PermutateS recursionOneS = new PermutateS();
         List<String> result = new ArrayList<>();
         recursionOneS.permutate(s, "", result);
         for (String ele : result) {