Add files via upload

Bubble.java

@@ -0,0 +1,46 @@
+import java.util.Scanner;
+class Bubble
+{
+    void bubblesort(int arr[])
+    {
+        int i,j,temp;
+        boolean swapped=false;
+        int n=arr.length;
+        for(i=0;i<n-1;i++)
+        {
+            for(j=0;j<n-i-1;j++)
+            {
+                swapped=false;
+                if(arr[j]>arr[j+1])
+                {
+                    temp=arr[j];
+                    arr[j]=arr[j+1];
+                    arr[j+1]=temp;
+                    swapped=true;
+                }
+            }
+            if(swapped==false)
+            {
+                break;
+            }
+        }
+    }
+    public static void main(String args[])
+    {
+        Bubble b=new Bubble();
+        Scanner sc=new Scanner(System.in);
+        int arr[]=new int[10];
+        for(int i=0;i<10;i++)
+        {
+            arr[i]=sc.nextInt();
+        }
+        b.bubblesort(arr);
+        System.out.println("Sorted array");
+        for(int i=0;i<arr.length;i++)
+        {
+            System.out.print(arr[i]);
+        }
+
+    }
+
+}

DivideNConquer/Closest.java

@@ -0,0 +1,39 @@
+//Considering the index is the x coordinate
+import java.io.*;
+class Closest
+{
+    static int calcdist(int arr[],int l,int r)
+    {
+        int min = 9999;  
+        int dist=0;
+        for (int i = l; i < r; ++i)  
+            for (int j = i+1; j < r; ++j)  
+            dist=(int)Math.sqrt(((j-i)*(j-i))+((arr[i]-arr[j])*(arr[i]-arr[j])));
+            if (dist < min)  
+                min = dist;  
+        return min;  
+    }
+    static int closest(int arr[])
+    {
+        int l=0;
+        int r=arr.length;
+        int mid=(l+r)/2;
+        int dl=calcdist(arr,0,mid+1);
+        int dr=calcdist(arr,mid+1,r);
+        int d3=0;//for calculating distance of split array containing 7 mid points
+        if(r>=7)
+        {
+            d3=calcdist(arr,mid-2,mid+5);
+        }
+        int d=Math.min(dl,dr);
+        int val=Math.min(d,d3);
+        return val;
+    }
+    public static void main(String args[])
+    {
+
+     int arr[]={13,15,12,7,14,16,1,10,17,9,2,11,23,18,24,5,0,6};
+     int c=closest(arr);
+     System.out.println("Distance between closest pair of points="+c);
+    }
+}

DivideNConquer/Duplicates.java

@@ -0,0 +1,103 @@
+import java.io.*;
+import java.util.*;
+class Duplicates
+{
+    static void sort(int arr[])
+    {
+        int n=arr.length;
+        for(int i=1;i<n;i++)
+        {
+            int key=arr[i];
+            int j=i-1;
+            while(j>=0 && arr[j]>key)
+            {
+                //move elements greater than key to one space ahead to make space for key
+                arr[j+1]=arr[j];
+                j--;
+            }
+            arr[j+1]=key;
+        }
+    }
+    public static int first(int arr[], int low, int high, int x, int n) 
+    { 
+        if (high >= low) { 
+            int mid = low + (high - low) / 2; 
+            if ((mid == 0 || x > arr[mid - 1]) && arr[mid] == x) 
+                return mid; 
+            else if (x > arr[mid]) 
+                return first(arr, (mid + 1), high, x, n); 
+            else
+                return first(arr, low, (mid - 1), x, n); 
+        } 
+        return -1; 
+    } 
+    public static int last(int arr[],int low,int high,int x,int n)
+    {
+        if(high>=low)
+        {
+            int mid=low+(high-low)/2;
+            if((mid==n-1||x<arr[mid+1])&&(arr[mid]==x))
+            {
+                return mid;
+            }
+            else if(arr[mid]>x)
+            {
+                return last(arr,low,mid-1,x,n);
+            }
+            else
+            {
+                return last(arr,mid+1,high,x,n);
+            }
+
+        }
+        return -1;
+    }
+    public static void main(String args[])
+    {
+            try 
+            {
+                /*FileReader fr=new FileReader("input.txt");
+                int ch;
+                int arr[]=new int[100];
+                int i=0;
+                int d=0;int num;
+                while((ch=fr.read())!=-1)
+                {
+                    num=0;
+                    while((char)ch!=',')
+                    {
+                        d=Character.getNumericValue((char)ch);
+                        num=(num*10)+d;
+                        ch=fr.read();
+
+                    }
+                    arr[i]=num;
+                    i++;
+                }
+                if(ch==-1)
+                {
+                    fr.close();*/
+                    int arr[]={1,1,2,3,4,5,6,7,8,9,9,9,9,9,9,9,10,11,20,23,23,23,23,67,67,67,67,89,101,105,106,106,106,106,106,203,245,245,245,367,8,8,8,8,34,34,52,1067,2345,435,567,567,890,780,657,123};
+                    Scanner sc=new Scanner(System.in);
+                    int i=arr.length;
+                    sort(arr);
+                    int x=sc.nextInt();
+                    int f=first(arr, 0, i - 1, x, i); 
+                    int l=last(arr, 0, i - 1, x, i); 
+                    int c=0;
+                    for(int j=f;j<=l;j++)
+                    {
+                        if(arr[j]==x)
+                        {
+                            c++;
+                        }
+                    }
+                    System.out.println("Number of occurences= "+c);
+                //}
+            }
+             catch (Exception e) 
+            {
+                System.out.println("Exception encountered");
+            }
+    }
+}

DivideNConquer/Dutch.java

@@ -0,0 +1,104 @@
+import java.io.*;
+
+class Pair {
+	private int x;
+	private int y;
+
+	Pair(int x, int y) {
+		this.x = x;
+		this.y = y;
+	}
+
+	public int getX() { return x; }
+	public int getY() { return y; }
+}
+
+class Dutch
+{
+    public static void swap (int[] arr, int i, int j) {
+		int temp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = temp;
+	}
+
+	// Partition routine using Dutch National Flag Algorithm
+	public static Pair Partition(int[] arr, int start, int end)
+	{
+		int mid = start;
+		int pivot = arr[end];
+
+		while (mid <= end) {
+			if (arr[mid] < pivot) {
+				swap(arr, start, mid);
+				++start;
+				++mid;
+			}
+			else if (arr[mid] > pivot) {
+				swap(arr, mid, end);
+				--end;
+			}
+			else {
+				++mid;
+			}
+		}
+
+		// arr[start .. mid - 1] contains all occurrences of pivot
+		return new Pair(start - 1, mid);
+	}
+
+	// Three-way Quicksort routine
+	public static void quicksort(int[] arr, int start, int end)
+	{
+		// base condition for 0 or 1 elements
+		if (start >= end) {
+			return;
+		}
+
+		// handle 2 elements separately as Dutch national flag
+		// algorithm will work for 3 or more elements
+		if (start - end == 1)
+		{
+			if (arr[start] < arr[end]) {
+				swap(arr, start, end);
+			}
+			return;
+		}
+
+		// rearrange the elements across pivot using Dutch
+		// national flag problem algorithm
+		Pair pivot = Partition(arr, start, end);
+
+		// recur on sub-array containing elements that are less than pivot
+		quicksort(arr, start, pivot.getX());
+
+		// recur on sub-array containing elements that are more than pivot
+		quicksort(arr, pivot.getY(), end);
+	}
+    public static void main(String[] args)throws Exception
+    { 
+        String arr[] = new String[100]; 
+        File f=new File("num.txt");
+        BufferedReader br = new BufferedReader(new FileReader(f));
+        String st; 
+        String s2="";
+        int num[]=new int[100];
+        while ((st = br.readLine()) != null) 
+           {
+               s2=s2.concat(st);
+           }
+        String words[]=s2.split(",");
+        int n=words.length;
+        for(int i1=0;i1<n;i1++)
+        {
+            num[i1]=Integer.parseInt(words[i1]);
+        }
+        quicksort(num,0,n-1);
+        System.out.println("Sorted array");
+        for(int j1=0;j1<n;j1++)
+        {
+            System.out.print(num[j1]+",");
+        }    
+
+    }
+}
+

DivideNConquer/Histo.java

@@ -0,0 +1,27 @@
+import java.util.*;
+class Histo
+{
+    static int area(int arr[])
+    {
+        int maxarea=0,minht=0;
+        for(int i=0;i<arr.length;i++)
+        {
+            maxarea=Math.max(arr[i],maxarea);
+            minht=arr[i];
+            for(int j=i-1;j>=0;j--)
+            {
+                minht=Math.min(arr[j],minht);
+                int width=(j-i+1);
+                maxarea=Math.max(maxarea,(minht*width));
+            }
+        }
+        return maxarea;
+    }
+    public static void main(String args[])
+    {
+        int arr[]={1,2,3,3,4,5,6,5,4};
+        int a=area(arr);
+        System.out.println("Area"+a);
+
+    }
+}

DivideNConquer/Hoare.java

@@ -0,0 +1,62 @@
+import java.io.*;
+class Hoare
+{
+    static int partition(int arr[],int lo,int hi)
+    {
+        int pivot = arr[lo];
+        int i=lo-1,j=hi+1;
+        while(true)
+        {
+            do
+            {
+                i++;
+            }while(arr[i]<pivot);
+
+            do{
+                j--;
+            }while(arr[j]>pivot);
+
+            if (i >= j) 
+            return j; 
+            int temp = arr[i]; 
+            arr[i] = arr[j]; 
+            arr[j] = temp;
+        }
+    }
+    static void quicksort(int []arr, int low,  
+                                 int high) 
+    { 
+        if (low < high) 
+        { 
+            int pi = partition(arr, low, high); 
+            quicksort(arr, low, pi); 
+            quicksort(arr, pi + 1, high); 
+        } 
+    } 
+    public static void main(String[] args)throws Exception
+    { 
+        String arr[] = new String[100]; 
+        File f=new File("num.txt");
+        BufferedReader br = new BufferedReader(new FileReader(f));
+        String st; 
+        String s2="";
+        int num[]=new int[100];
+        while ((st = br.readLine()) != null) 
+           {
+               s2=s2.concat(st);
+           }
+        String words[]=s2.split(",");
+        int n=words.length;
+        for(int i1=0;i1<n;i1++)
+        {
+            num[i1]=Integer.parseInt(words[i1]);
+        }
+        quicksort(num,0,n-1);
+        System.out.println("Sorted array");
+        for(int j1=0;j1<n;j1++)
+        {
+            System.out.print(num[j1]+",");
+        }    
+
+    }
+}