#Modification 140

Author: amangit1314

arrays/Array_Problem_17.java

@@ -1,10 +1,31 @@
 package arrays;
 
-/* Problem Title :-> Best Time to buy and sell stocks */
+//? Problem Title :-> Best Time to buy and sell stocks [1] 
+
+// * You are allowed to buy and sell only once
+// ! You are not allowed to sell first and then buy, 
+// ! (you must buy first and then sell)
+
 public class Array_Problem_17 {
 
   public int maxProfit(int[] prices) {
+    int mini = prices[0];
     int maxProfit = 0;
+    
+    int n = prices.size();
+
+    for(int i = 0; i < n; i++) {
+      int cost = prices[i] - mini;
+      maxProfit = Math.max(maxProfit, cost);
+      mini = Math.min(mini, prices[i]);
+    }
+    
     return maxProfit;
   }
+
+  	//Driver Method
+	public static void main(String[] args) {
+		int[] prices = {2, 7, 4, -5, 11, 5, 20};
+		System.out.println("Max profit is -> " + maxProfit(prices));
+	}
 }

arrays/Array_Problem_26.java

@@ -1,18 +1,21 @@
 package arrays;
-/* Problem Title :->  Maximum profit by buying and selling a share atmost twice
-*/
+
+//? Problem Title :-> Maximum profit by buying and selling a share atmost twice
+
+// * You are allowed to buy and sell atmost twice
+
 public class Array_Problem_26 {
 	static int maxProfit(int[] price, int n) {
 
 		int[] profit = new int[n];
 
-		for(int i =0; i < n; i++) {
+		for(int i = 0; i < n; i++) {
 			profit[i] = 0;
 		}
 
 		int max_price = price[n-1];
 
-		for(int i = n -2; i >= 0; i--) {
+		for(int i = n - 2; i >= 0; i--) {
 			if(price[i] > max_price)
 				max_price = price[i];
 
@@ -27,7 +30,7 @@ static int maxProfit(int[] price, int n) {
 				min_price = price[i];
 
 			profit[i]= Math.max(
-					profit[i-1],
+					profit[i - 1],
 					profit[i] + (price[i] - min_price)
 			);
 		}

arrays/Array_Problem_28.java

@@ -1,5 +1,32 @@
 package arrays;
-/* Problem Title :->  Find whether an arrays.array is a subset of another arrays.array
-*/
+// ? Problem Title :->  Find whether an array is a subset of another array
+
 public class Array_Problem_28 {
+
+    public static void main(String[] args) {
+ 
+        int arr1[] = { 11, 1, 13, 21, 3, 7 };
+        int arr2[] = { 11, 3, 7, 1 };
+        
+        int m = arr1.length;
+        int n = arr2.length;
+ 
+        Set<Integer> s = new HashSet<Integer>();
+        for (int i = 0; i < m; i++) {
+            s.add(arr1[i]);
+        }
+
+        int p = s.size();
+        for (int i = 0; i < n; i++) {
+            s.add(arr2[i]);
+        }
+ 
+        if (s.size() == p) {
+            System.out.println("arr2[] is subset of arr1[] " + "\n");
+        }
+
+        else {
+            System.out.println("arr2[] is not subset of arr1[] " + "\n");
+        }
+    }
 }

arrays/Array_Problem_29.java

@@ -16,6 +16,7 @@ boolean find3Numbers(int[] A, int a_size, int sum) {
 		}
 		return false;
 	}
+	
 	public static void main(String[] args) {
 		Array_Problem_29 triplet = new Array_Problem_29();
 		int[] A = {1, 4, 45, 6, 10, 8};

linkedList/Problem_11.txt

@@ -120,3 +120,97 @@ Output
 Complexity Analysis:
 
 Time Complexity: O(n)
+
+
+package linkedList;
+// Pronblem Title => Intersection Point of two Linked Lists. 
+public class Problem_11 {
+    static Node head1, head2;
+
+    static class Node {
+
+        int data;
+        Node next;
+
+        Node(int d) {
+            data = d;
+            next = null;
+        }
+    }
+
+    /*
+     * function to get the intersection point of two linked lists head1 and head2
+     */
+    int getNode() {
+        int c1 = getCount(head1);
+        int c2 = getCount(head2);
+        int d;
+
+        if (c1 > c2) {
+            d = c1 - c2;
+            return _getIntesectionNode(d, head1, head2);
+        } else {
+            d = c2 - c1;
+            return _getIntesectionNode(d, head2, head1);
+        }
+    }
+
+    /*
+     * function to get the intersection point of two linked lists head1 and head2
+     * where head1 has d more nodes than head2
+     */
+    int _getIntesectionNode(int d, Node node1, Node node2) {
+        int i;
+        Node current1 = node1;
+        Node current2 = node2;
+        for (i = 0; i < d; i++) {
+            if (current1 == null) {
+                return -1;
+            }
+            current1 = current1.next;
+        }
+        while (current1 != null && current2 != null) {
+            if (current1.data == current2.data) {
+                return current1.data;
+            }
+            current1 = current2;
+            current2 = current2.next;
+        }
+
+        return -1;
+    }
+
+    /*
+     * Takes head pointer of the linked linkedList.list and returns the count of nodes in the
+     * linkedList.list
+     */
+    int getCount(Node node) {
+        Node current = node;
+        int count = 0;
+
+        while (current != null) {
+            count++;
+            current = current.next;
+        }
+
+        return count;
+    }
+
+    public static void main(String[] args) {
+        Problem_11 list = new Problem_11();
+
+        // creating first linked linkedList.list
+        list.head1 = new Node(3);
+        list.head1.next = new Node(6);
+        list.head1.next.next = new Node(9);
+        list.head1.next.next.next = new Node(15);
+        list.head1.next.next.next.next = new Node(30);
+
+        // creating second linked linkedList.list
+        list.head2 = new Node(10);
+        list.head2.next = new Node(15);
+        list.head2.next.next = new Node(30);
+
+        System.out.println("The node of intersection is " + list.getNode());
+    }
+}

linkedList/Problem_12.java

@@ -1,5 +1,5 @@
 package linkedList;
-// Pronblem Title => Intersection Point of two Linked Lists. 
+// Pronblem Title => Merge Sort for linked lists [Very Important]. 
 public class Problem_12 {
     static Node head1, head2;
 
@@ -14,79 +14,63 @@ static class Node {
         }
     }
 
-    /*
-     * function to get the intersection point of two linked lists head1 and head2
-     */
-    int getNode() {
-        int c1 = getCount(head1);
-        int c2 = getCount(head2);
-        int d;
-
-        if (c1 > c2) {
-            d = c1 - c2;
-            return _getIntesectionNode(d, head1, head2);
-        } else {
-            d = c2 - c1;
-            return _getIntesectionNode(d, head2, head1);
-        }
-    }
+static Node mergeSort(Node head) {
+    if(head == null || head.next == null)
+        return head;
 
-    /*
-     * function to get the intersection point of two linked lists head1 and head2
-     * where head1 has d more nodes than head2
-     */
-    int _getIntesectionNode(int d, Node node1, Node node2) {
-        int i;
-        Node current1 = node1;
-        Node current2 = node2;
-        for (i = 0; i < d; i++) {
-            if (current1 == null) {
-                return -1;
-            }
-            current1 = current1.next;
-        }
-        while (current1 != null && current2 != null) {
-            if (current1.data == current2.data) {
-                return current1.data;
-            }
-            current1 = current2;
-            current2 = current2.next;
-        }
+    Node middle = getMiddle(head);
+    Node right = middle.next;
+    middle.next = null;
+    Node left = mergeSort(left);
+    Node left1 = mergeSort(left);
+    Node left2 = mergeSort(right);
+    return merge(left1, left2);
+}
+
+static Node getMiddle(Node head) {
+    Node slow = head;
+    Node fast = head.next;
 
-        return -1;
+    while(fasty != null && fast.next != null) {
+        slow = slow.next;
+        fast = fast.next.next;
     }
 
-    /*
-     * Takes head pointer of the linked linkedList.list and returns the count of nodes in the
-     * linkedList.list
-     */
-    int getCount(Node node) {
-        Node current = node;
-        int count = 0;
-
-        while (current != null) {
-            count++;
-            current = current.next;
-        }
+    return slow;
+}
+
+static Node merge(Node head1, Node head2) {
+    if(head1 == null)
+    return head2;
 
-        return count;
+    if(head2 == null)
+    return head1;
+
+    if(head1.data < head2.data) {
+        head1.next = merge(head1.next, head2);
+        return head1;
+    } else {
+        head2.next = merge(head1, head2.next);
+        return head2;
     }
+}
 
     public static void main(String[] args) {
         Problem_12 list = new Problem_12();
 
-        // creating first linked linkedList.list
-        list.head1 = new Node(3);
-        list.head1.next = new Node(6);
-        list.head1.next.next = new Node(9);
-        list.head1.next.next.next = new Node(15);
-        list.head1.next.next.next.next = new Node(30);
+        list.head1 = new Node(1);
+        list.head1.next = new Node(3);
+        list.head1.next.next = new Node(5);
+        list.head1.next.next.next = new Node(7);
+
+        list.head2 = new Node(2);
+        list.head2.next = new Node(4);
+        list.head2.next.next = new Node(6);
+        list.head2.next.next.next = new Node(8);
 
-        // creating second linked linkedList.list
-        list.head2 = new Node(10);
-        list.head2.next = new Node(15);
-        list.head2.next.next = new Node(30);
+        Node result = mergeSort(head1);
+        printList(result);
 
-        System.out.println("The node of intersection is " + list.getNode());
+        
     }
 }