Singlelinkedlist

Leetcode/MajorityElement.java

@@ -0,0 +1,50 @@
+package Leetcode;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/*
+ * Given an array nums of size n, return the majority element.
+
+The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.
+
+
+
+Example 1:
+
+Input: nums = [3,2,3]
+Output: 3
+Example 2:
+
+Input: nums = [2,2,1,1,1,2,2]
+Output: 2
+ * 
+ * 
+ */
+
+public class MajorityElement {
+
+    public static void main(String[] args) {
+        var me = new MajorityElement();
+        me.majorityElement(new int[]{2,2,1,1,1,2,2});
+    }
+
+    public int majorityElement(int[] nums) {
+
+        HashMap<Integer,Integer> x = new HashMap<>();
+        for(int i=0;i<nums.length;i++){
+            if(x.get(nums[i])==null) x.put(nums[i],1);
+            else{
+                x.put(nums[i],x.get(nums[i])+1);
+            }
+        }
+
+        for (Map.Entry<Integer,Integer> entry : x.entrySet()){ 
+
+            if(entry.getValue()>nums.length/2) return entry.getKey();    
+
+        }
+
+        return -1;
+    }
+}

Leetcode/SearchInSortedArray.java

@@ -0,0 +1,48 @@
+package Leetcode;
+
+/*
+ * 
+ * There is an integer array nums sorted in ascending order (with distinct values).
+
+Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k (1 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2].
+
+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.
+
+You must write an algorithm with O(log n) runtime complexity.
+
+
+
+Example 1:
+
+Input: nums = [4,5,6,7,0,1,2], target = 0
+Output: 4
+Example 2:
+
+Input: nums = [4,5,6,7,0,1,2], target = 3
+Output: -1
+Example 3:
+
+Input: nums = [1], target = 0
+Output: -1
+
+Runtime: 0 ms, faster than 100.00% of Java online submissions for Search in Rotated Sorted Array.
+Memory Usage: 42.9 MB, less than 32.59% of Java online submissions for Search in Rotated Sorted Array.
+ * 
+ */
+public class SearchInSortedArray {
+
+    public static void main(String[] args) {
+        var sisa = new SearchInSortedArray();
+        System.out.println(sisa.search(new int[]{4,5,6,7,0,1,2}, 0));
+    }
+
+    public int search(int[] nums, int target) {
+        int j=nums.length-1;
+       for(int i=0;i<=nums.length/2;i++){
+           if(nums[i]==target) return i;
+           else if(nums[j]==target) return j;
+           j--;
+       }
+        return -1;
+    }
+}