Add files via upload

Author: bharathikannann

Searching and Sorting/Binary Search/BinarySearch.java

@@ -0,0 +1,38 @@
+package com.company;
+
+import java.util.Scanner;
+
+public class BinarySearch {
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        System.out.println("Enter the array size");
+        int n=sc.nextInt();
+        int a[]=new int[n];
+        System.out.println("Enter the numbers");
+        for(int i=0;i<n;i++) {
+            a[i] = sc.nextInt();
+        }
+        System.out.println("Enter the search number");
+        int searchnumber=sc.nextInt();
+        if(binarysearch(a,searchnumber)!=-1)
+            System.out.println("The number "+ binarysearch(a,searchnumber)+" is present in the array");
+        else
+        System.out.println("The number is not present in the array");
+    }
+    public static int binarysearch(int[] array,int number){
+        int low=0,mid=0;
+        int high=array.length-1;
+        while(low<=high){
+            mid=(high+low)/2;
+            if(mid==number)
+                return mid;
+            if(number<mid)
+                high=mid-1;
+            else if(number>mid)
+                low=mid+1;
+        }
+        return -1;
+    }
+
+
+}

Searching and Sorting/InsertionSort/InsertionSort.java

@@ -0,0 +1,34 @@
+import java.util.Scanner;
+
+public class InsertionSort {
+    public static Scanner scanner=new Scanner(System.in);
+    public static void main(String args[]) {
+        System.out.println("Enter the number of inputs");
+        int n=scanner.nextInt();
+        int[] myIntegers=getIntegers(n);
+        sort(myIntegers);
+        for(int i=0;i<myIntegers.length;i++){
+            System.out.println(myIntegers[i]);
+        }
+    }
+
+    public static int[] getIntegers(int number){
+        System.out.println("Enter the values");
+        int[] values=new int[number];
+        for(int i=0;i<number;i++){
+            values[i]=scanner.nextInt();
+        }
+        return values;
+    }
+    public static void sort(int[] array){
+        for(int i=1;i<array.length;i++){
+            for(int j=i;j>0;j--){
+                if(array[j]<array[j-1]){
+                    int temp=array[j-1];
+                    array[j-1]=array[j];
+                    array[j]=temp;
+                }
+            }
+        }
+    }
+}

Searching and Sorting/Merge Sort for Linked List/SortingLinkedList.java

@@ -0,0 +1,80 @@
+package com.company;
+
+public class SortingLinkedList {
+    static class Node {
+        int data;
+        Node next;
+    }
+    Node head;
+    public int size(){
+        int count=0;
+        if(head==null){
+            count=0;
+        }else{
+            Node n=head;
+            while(n!=null){
+                count++;
+                n=n.next;
+            }
+        }
+        return count;
+    }
+    public void insert(int data){
+        Node node=new Node();
+        node.data=data;
+        node.next=null;
+        if(head==null){
+            head=node;
+        }else{
+            Node n=head;
+            while(n.next!=null){
+                n=n.next;
+            }
+            n.next=node;
+        }
+    }
+    public void show(){
+        Node node=head;
+        while(node!=null){
+            System.out.println(node.data);
+            node=node.next;
+        }
+    }
+    public void sort(){
+        head=mergeSort(head);
+    }
+    private Node mergeSort(Node head){
+        if(head==null || head.next==null){
+            return head;
+        }
+        Node temp=head;
+        Node slow=head;
+        Node fast=head;
+        while(fast!=null && fast.next!=null){
+            temp=slow;
+            slow=slow.next;
+            fast=fast.next.next;
+        }
+        temp.next=null;
+        Node left=mergeSort(head);
+        Node right=mergeSort(slow);
+        return merge(left,right);
+    }
+    private Node merge(Node a,Node b){
+        Node result=null;
+        if(a==null){
+            return b;
+        }
+        if(b==null){
+            return a;
+        }
+        if(a.data<=b.data){
+            result=a;
+            result.next=merge(a.next,b);
+        }else{
+            result=b;
+            result.next=merge(a,b.next);
+        }
+        return result;
+    }
+}

Searching and Sorting/Merge Sort/MergeSort.java

@@ -0,0 +1,37 @@
+package com.company;
+
+public class MergeSort {
+    void sort(int arr[],int beg,int end) {
+        if(beg < end) {
+            int mid = (beg + end) / 2;
+            sort(arr, beg, mid);
+            sort(arr, mid + 1, end);
+            mergesort(arr, beg, mid, end);
+        }
+    }
+    void mergesort(int arr[],int beg,int mid,int end){
+        int left=mid-beg+1;
+        int right=end-mid;
+        int[] leftarray=new int[left];
+        int[] rightarray=new int[right];
+        for(int i=0;i<left;i++){
+            leftarray[i]=arr[beg+i];
+        }
+        for(int i=0;i<right;i++){
+            rightarray[i]=arr[mid+i+1];
+        }
+        int i=0,j=0,k=beg;
+        while(i<left&&j<right){
+            if(leftarray[i]<rightarray[j])
+                arr[k++]=leftarray[i++];
+            else
+                arr[k++]=rightarray[j++];
+        }
+        while(i<left){
+            arr[k++]=leftarray[i++];
+        }
+        while(j<right){
+            arr[k++]=rightarray[j++];
+        }
+    }
+}

Searching and Sorting/Merge Two Sorted Linked List/MergeTwoLinkedList.java

@@ -0,0 +1,69 @@
+package com.company;
+
+public class MergeTwoLinkedList {
+    class Node {
+        int data;
+        Node next;
+    }
+    Node head;
+    public int size(){
+        int count=0;
+        if(head==null){
+            count=0;
+        }else{
+            Node n=head;
+            while(n!=null){
+                count++;
+                n=n.next;
+            }
+        }
+        return count;
+    }
+    public void insert(int data){
+        Node node=new Node();
+        node.data=data;
+        node.next=null;
+        if(head==null){
+            head=node;
+        }else{
+            Node n=head;
+            while(n.next!=null){
+                n=n.next;
+            }
+            n.next=node;
+        }
+    }
+    public void show(){
+        Node node=head;
+        while(node!=null){
+            System.out.println(node.data);
+            node=node.next;
+        }
+    }
+    public void merge(MergeTwoLinkedList m1,MergeTwoLinkedList m2){
+        m1.head=mergeSortedLinkedList(m1.head,m2.head);
+    }
+    public Node mergeSortedLinkedList(Node a,Node b){
+        Node dummyHead=new Node();
+        Node tail=dummyHead;
+        while(true){
+            if(a==null) {
+                tail.next = b;
+                break;
+            }
+            if(b==null) {
+                tail.next = a;
+                break;
+            }
+            if(a.data<b.data){
+                tail.next=a;
+                a=a.next;
+            }else{
+                tail.next=b;
+                b=b.next;
+            }
+            tail=tail.next;
+        }
+        return dummyHead.next;
+    }
+}

Searching and Sorting/Merge Two Sorted Linked List/Test.java

@@ -0,0 +1,13 @@
+package com.company;
+public class Test {
+    public static void main (String[] args) {
+        MergeTwoLinkedList mll1 = new MergeTwoLinkedList();
+        mll1.insert(2);
+        mll1.insert(4);
+        MergeTwoLinkedList mll2 = new MergeTwoLinkedList();
+        mll2.insert(3);
+        mll2.insert(5);
+        mll1.merge(mll1,mll2);
+        mll1.show();
+    }
+}

Searching and Sorting/QuickSort/QuickSort.java

@@ -0,0 +1,36 @@
+class QSort{
+    public int partition(int[] array,int l,int h){
+        int i=l;
+        int pivot=array[h];
+        for(int j=l;j<h;j++){
+            if(array[j]<=pivot){
+                int temp=array[i];
+                array[i]=array[j];
+                array[j]=temp;
+                i++;
+            }
+        }
+        int temp=array[i];
+        array[i]=array[h];
+        array[h]=temp;
+        return i;
+    }
+    public void sort(int[] array,int l,int h){
+        if(l<h){
+            int p=partition(array,l,h);
+            sort(array,l,p-1);
+            sort(array,p+1,h);
+        }
+    }
+}
+public class QuickSort {
+    public static void main (String[] args) {
+    int[] array={10, 7, 8, 9, 1, 5,6,34,521,6,31,35216,621,62,2136,4126,62};
+    int n=array.length;
+    QSort qs=new QSort();
+    qs.sort(array,0,n-1);
+    for(int i=0;i<n;i++){
+        System.out.println(array[i]);
+    }
+    }
+}

Searching and Sorting/SelectionSort/SelectionSort.java

@@ -0,0 +1,36 @@
+import java.util.Scanner;
+
+public class SelectionSort {
+    public static Scanner scanner=new Scanner(System.in);
+    public static void main(String args[]) {
+        System.out.println("Enter the number of inputs");
+        int n=scanner.nextInt();
+        int[] myIntegers=getIntegers(n);
+        sort(myIntegers);
+        for(int i=0;i<myIntegers.length;i++){
+            System.out.println(myIntegers[i]);
+        }
+    }
+
+    public static int[] getIntegers(int number){
+        System.out.println("Enter the values");
+        int[] values=new int[number];
+        for(int i=0;i<number;i++){
+            values[i]=scanner.nextInt();
+        }
+        return values;
+    }
+    public static void sort(int[] array){
+        for(int i=0;i<array.length;i++){
+            int min=i,temp=0;
+            for(int j=i+1;j<array.length;j++){
+                if(array[j]<array[min]){
+                   min=j;
+                }
+            }
+            temp=array[i];
+            array[i]=array[min];
+            array[min]=temp;
+        }
+    }
+}