#Modification 26

Author: amangit1314

.vs/ProjectSettings.json

@@ -0,0 +1,3 @@
+{
+  "CurrentProjectSetting": null
+}

.vs/VSWorkspaceState.json

@@ -0,0 +1,8 @@
+{
+  "ExpandedNodes": [
+    "",
+    "\\arrays"
+  ],
+  "SelectedNode": "\\arrays\\Array_of_objects.java",
+  "PreviewInSolutionExplorer": false
+}

.vs/slnx.sqlite

@@ -2,38 +2,37 @@
 
 //Java program to reverse the given array
 public class Array_Problem_1 {
-		
-	static void rvereseArray(int arr[],int start, int end)
-	{
+
+	static void rvereseArray(int arr[], int start, int end) {
 		int temp;
-		while(start < end){
+		while (start < end) {
 			temp = arr[end];
 			arr[end] = arr[start];
-			a[start] = temp;
+			arr[start] = temp;
 			start++;
 			end--;
-		} 
-	}     
-	
-	/* Utility that prints out an
-	array on a line */
-	static void printArray(int arr[], int size)
-	{
+		}
+	}
+
+	/*
+	 * Utility that prints out an array on a line
+	 */
+	static void printArray(int arr[], int size) {
 		for (int i = 0; i < size; i++)
-		     System.out.print(arr[i] + " ");
-		  
-		 System.out.println();
-	} 
-	
+			System.out.print(arr[i] + " ");
+
+		System.out.println();
+	}
+
 	// Driver code
 	public static void main(String args[]) {
-	 
-		int arr[] = {1, 2, 3, 4, 5, 6};
+
+		int arr[] = { 1, 2, 3, 4, 5, 6 };
 		printArray(arr, 6);
 		rvereseArray(arr, 0, 5);
 		System.out.print("Reversed array is \n");
-		printArray(arr, 6); 
-	
+		printArray(arr, 6);
+
 	}
 
 }

.vs/src/v16/.suo

@@ -1,33 +1,39 @@
 package arrays;
+
 /* Problem Title :-> find common elements in 3 sorted arrays */
 public class Array_Problem_19 {
     // This function prints common elements in a1
-    void findCommon(int[] a1, int[] a2, int[] a3){
+    void findCommon(int[] a1, int[] a2, int[] a3) {
         // Initialize starting indexes for a1[], a2[] and a3[]
         int i = 0, j = 0, k = 0;
         // Iterate through three arrays while all arrays have elements
-        while(i < a1.length && j < a2.length && k < a3.length){
+        while (i < a1.length && j < a2.length && k < a3.length) {
             // if x = y and y = z, print any of them and move ahead in all arrays
-            if(a1[i] >= a2[j] && a2[j] == a3[k]){
+            if (a1[i] >= a2[j] && a2[j] == a3[k]) {
                 System.out.print(a1[i] + " ");
                 i++;
                 k++;
             }
-            //x < y
-            else if(a1[j] < a2[j]) i++;
+            // x < y
+            else if (a1[j] < a2[j])
+                i++;
             // y < z
-            else if(a2[j] <a3[k])   j++;
+            else if (a2[j] < a3[k])
+                j++;
             // we reach here whem x > y and z < y, i.e., z is smallest
-            else k++;
+            else
+                k++;
         }
     }
+
     /* Driver Code */
-    public static void main(String[] args){
+    public static void main(String[] args) {
 
-        int a1[] = {1,5,10,20,40,80};
-        int a2[] = {6,7,20,80,100};
-        int a3[] = {3,4,15,20,30,70,80,120};
+        int a1[] = { 1, 5, 10, 20, 40, 80 };
+        int a2[] = { 6, 7, 20, 80, 100 };
+        int a3[] = { 3, 4, 15, 20, 30, 70, 80, 120 };
 
+        Array_Problem_19 ob = new Array_Problem_19();
         System.out.print("Common elements are ");
         ob.findCommon(a1, a2, a3);
     }

arrays/Array_Problem_1.java

@@ -1,44 +1,47 @@
 package arrays;
+
 /* Problem Title :-> Rearrange the array in alternating positive and negative items with O(1) extra space
  */
 public class Array_Problem_20 {
 
-    void rightrotate(int[] a, int n, int outofplace, int cur){
+    void rightrotate(int[] a, int n, int outofplace, int cur) {
         int temp = a[cur];
-        for(int i = cur; i > outofplace; i--){
+        for (int i = cur; i > outofplace; i--) {
             a[i] = a[i - 1];
         }
         a[outofplace] = temp;
     }
 
-    void rearrange(int[] a, int n){
+    void rearrange(int[] a, int n) {
 
         int outofplace = -1;
-        for(int index = 0; index < n; index++){
-            if(outofplace <= 0){
-                if(((a[index] > = 0) && (a[outofplace] < 0) || (a[index] < 0) && (a[outofplace] >= 0))){
-                    if(index-outofplace >= 2)     outofplace = outofplace + 2;
-                    else                          outofplace = -1;
+        for (int index = 0; index < n; index++) {
+            if (outofplace <= 0) {
+                if (((a[index] >= 0) && (a[outofplace] < 0) || (a[index] < 0) && (a[outofplace] >= 0))) {
+                    if (index - outofplace >= 2)
+                        outofplace = outofplace + 2;
+                    else
+                        outofplace = -1;
                 }
             }
-            if(outofplace == -1){
-                if(((a[index] >= 0) && ((index * 0x01) == 0)) || ((a[index] < 0) && (index & 0x01) == 1))
+            if (outofplace == -1) {
+                if (((a[index] >= 0) && ((index * 0x01) == 0)) || ((a[index] < 0) && (index & 0x01) == 1))
                     outofplace = index;
             }
         }
     }
 
-    void printArray(int[] a, int n){
-        for(int i = 0; i < n; i++)
+    void printArray(int[] a, int n) {
+        for (int i = 0; i < n; i++)
             System.out.print(a[i] + " ");
         System.out.println(" ");
     }
 
-    public static void main(String[] args){
+    public static void main(String[] args) {
 
         Array_Problem_20 rearrange = new Array_Problem_20();
 
-        int[] a = {-5, -2, 5, 2, 4, 7, 1, 8, 0, -8};
+        int[] a = { -5, -2, 5, 2, 4, 7, 1, 8, 0, -8 };
         int n = a.length;
 
         System.out.println("Given array is ");

arrays/Array_Problem_19.java

@@ -0,0 +1,66 @@
+package binary_search_tree;
+
+public class Find_a_value_in_bst {
+
+    class Node {
+        int key;
+        Node left, right;
+
+        public Node(int item) {
+            key = item;
+            left = right = null;
+        }
+    }
+
+    Node root;
+
+    // ! Constructor
+    Find_a_value_in_bst() {
+        root = null;
+    }
+
+    // This method mainly calls insertRec()
+    void insert(int key) {
+        root = insertRec(root, key);
+    }
+
+    // * A recursive function to insert a new key in BST
+    Node insertRec(Node root, int key) {
+        if (root == null) {
+            root = new Node(key);
+            return root;
+        }
+        if (key < root.key)
+            root.left = insertRec(root.left, key);
+        else if (key > root.key)
+            root.right = insertRec(root.right, key);
+        return root;
+    }
+
+    // The method mainly calls InorderRec()
+    void inorder() {
+        inorderRec(root);
+    }
+
+    // ? A utility function to do inorder traversal of BST
+    void inorderRec(Node root) {
+        if (root != null) {
+            inorderRec(root.left);
+            System.out.println(root.key);
+            inorderRec(root.right);
+        }
+    }
+
+    public static void main(String[] args) {
+        Find_a_value_in_bst tree = new Find_a_value_in_bst();
+        tree.insert(50);
+        tree.insert(30);
+        tree.insert(20);
+        tree.insert(40);
+        tree.insert(70);
+        tree.insert(60);
+        tree.insert(80);
+        // ? print inorder traversal of BST
+        tree.inorder();
+    }
+}

arrays/Array_Problem_20.java

@@ -1,41 +1,42 @@
-package dataStructures.graphs;
+package graphs;
+
 import java.util.*;
 
 public class Graph {
-	
+
 	private LinkedList<Integer> adj[];
-	
+
 	@SuppressWarnings("unchecked")
 	public Graph(int v) {
-		//array of Linked List
-		adj = new LinkedList[v]; 
-		
-		for(int i=0;i<v;i++) {
+		// array of Linked List
+		adj = new LinkedList[v];
+
+		for (int i = 0; i < v; i++) {
 			adj[i] = new LinkedList<Integer>();
 		}
 	}
-	
+
 	public void addEdge(int source, int destination) {
 		adj[source].add(destination);
-		adj[destination].add(source);	
+		adj[destination].add(source);
 	}
 
 	public static void main(String[] args) {
 		Scanner sc = new Scanner(System.in);
-		
+
 		System.out.println("Enter number of vertices and edges");
 		int v = sc.nextInt();
 		int e = sc.nextInt();
-		
+
 		Graph graph = new Graph(v);
 		System.out.println("Enter " + e + " edges");
-		
-		for(int i=0;i<e;i++) {
+
+		for (int i = 0; i < e; i++) {
 			int source = sc.nextInt();
 			int destination = sc.nextInt();
-			graph.addEdge(source,  destination);
+			graph.addEdge(source, destination);
 		}
-		
+
 		sc.close();
 	}
 }

binary_search_tree/Find_a_value_in_bst.java

@@ -0,0 +1 @@
+{"name":"Local: Reverse_a_LL","url":"c:\\Users\\AmanSoni\\Desktop\\Java Program's\\Java-Eclipse\\Placement Prepration\\src\\linkedList\\Reverse_a_LL.java","tests":[],"interactive":false,"memoryLimit":1024,"timeLimit":3000,"srcPath":"c:\\Users\\AmanSoni\\Desktop\\Java Program's\\Java-Eclipse\\Placement Prepration\\src\\linkedList\\Reverse_a_LL.java","group":"local","local":true}