Merge pull request #1 from wildchaser1703/wildchaser1703-patch-1

Added Searching Algorithms

Author: wildchaser1703

java/searching/BFS.java

@@ -0,0 +1,79 @@
+// Implementation of BFS in Java
+// BFS(int s) traverses vertices reachable from s.
+import java.io.*;
+import java.util.*;
+
+class BFS
+{
+ private int V; // No. of vertices
+ private LinkedList<Integer> adjacent[]; //Adjacency Lists
+
+ // Constructor
+ BFS(int v)
+ {
+ V = v;
+ adjacent = new LinkedList[v];
+ for (int i=0; i<v; ++i)
+ adjacent[i] = new LinkedList();
+ }
+
+ // Function to add an edge into the graph
+ void addEdge(int v,int w)
+ {
+ adjacent[v].add(w);
+ }
+
+ // prints BFS traversal from a given source s
+ void BFS(int s)
+ {
+ // Mark all the vertices as not visited
+ // False
+ boolean visited[] = new boolean[V];
+
+ // Create a queue for BFS
+ LinkedList<Integer> queue = new LinkedList<Integer>();
+
+ // Mark the current node as visited and enqueue it
+ visited[s]=true;
+ queue.add(s);
+
+ while (queue.size() != 0)
+ {
+ // Dequeue a vertex from queue and print it
+ s = queue.poll();
+ System.out.print(s+" ");
+
+ // Get all adjacent vertices of the dequeued vertex s
+ // If a adjacent has not been visited, then mark it
+ // visited and enqueue it
+ Iterator<Integer> i = adjacent[s].listIterator();
+ while (i.hasNext())
+ {
+ int n = i.next();
+ if (!visited[n])
+ {
+ visited[n] = true;
+ queue.add(n);
+ }
+ }
+ }
+ }
+
+ // Driver code to check implementation
+ public static void main(String args[])
+ {
+ BFS bfs = new BFS(4);
+
+ bfs.addEdge(0, 1);
+ bfs.addEdge(0, 2);
+ bfs.addEdge(1, 2);
+ bfs.addEdge(2, 0);
+ bfs.addEdge(2, 3);
+ bfs.addEdge(3, 3);
+
+ System.out.println("Breadth First Traversal "+
+ "(starting from vertex 2)");
+
+ bfs.BFS(2);
+ }
+}

java/searching/BinarySearch.java

@@ -0,0 +1,44 @@
+// Code for Binary Search in Java
+// Assume array is sorted
+// Array is divided into two parts
+// Based on the position of mid
+// If element is found returns the index
+// Else returns -1
+class BinarySearch{
+ int bSearch(int arr[], int left, int right, int element)
+ {
+ if (right >= left) {
+ int mid = left + (right - left) / 2;
+
+ // If the element is present at mid
+ if (arr[mid] == element)
+ return mid;
+
+ // If element is smaller than mid
+ // search in left subarray
+ if (arr[mid] > element)
+ return bSearch(arr, left, mid - 1, element);
+
+ // If element is greater than mid
+ // search in right subarray
+ return bSearch(arr, mid + 1, right, element);
+ }
+
+ // If not found, return -1
+ return -1;
+ }
+
+ // Driver code to test
+ public static void main(String args[])
+ {
+ BinarySearch elt = new BinarySearch();
+ int arr[] = { 5, 10, 70, 100, 499 };
+ int size = arr.length;
+ int x = 5;
+ int result = elt.bSearch(arr, 0, size - 1, x);
+ if (result == -1)
+ System.out.println("Element not present");
+ else
+ System.out.println("Element found at index " + result);
+ }
+}

java/searching/LinearSearch.java

@@ -0,0 +1,26 @@
+// Code for linearly searching x in arr[].
+//If found returns the location.
+//If not found returns -1.
+public class LinearSearch {
+ public static int search(int arr[], int x) {
+ int size = arr.length;
+ for (int i = 0; i < size; i++) {
+ if (arr[i] == x)
+ return i;
+ }
+ return -1;
+ }
+
+ // Driver code
+ public static void main(String args[]) {
+ int arr[] = {11, 41, 47, 108, 490};
+ int x = 14;
+
+ // Function call
+ int result = search(arr, x);
+ if (result == -1)
+ System.out.print("Element is not present in array");
+ else
+ System.out.print("Element is present at index " + result);
+ }
+}