Add files via upload

JAVA/DSA in java/Searching in java/binarysearch.java

@@ -0,0 +1,25 @@
+import java.util.*;
+public class binarysearch {
+    public static int bin(int numbers[],int key){
+        int start=0,end = numbers.length-1;
+
+        while(start<=end){
+            int mid=(start+end)/2;
+            if(numbers[mid]==key){
+                return mid;
+            }
+            if(numbers[mid]<key){
+                start=mid+1;
+            }
+            else{
+                end=mid-1;
+            }
+        }
+        return -1;
+    }
+    public static void main(String args[]){
+        int numbers[] = {1,2,6,3,5};
+        int key=6;
+        System.out.println("nu is largest : " + bin(numbers,key));
+    }
+}

JAVA/DSA in java/Searching in java/linearsearch.java

@@ -0,0 +1,21 @@
+public class linearsearch {
+    public static int linea(int numbers[],int key){
+        for(int i =0;i<numbers.length;i++){
+            if(numbers[i]==key){
+                return i;
+            }
+        }
+        return -1;
+    }
+    public static void main(String args[]){
+        int numbers[]={2,4,6,8,10,12,14,16};
+        int key=10;
+        int index=linea(numbers,key);
+        if(index==-1){
+            System.out.print("not");
+        }
+        else{
+            System.out.print("key is at index " + index);
+        }
+    }
+}

JAVA/DSA in java/kadanes.java

@@ -0,0 +1,21 @@
+public class kadanes {
+    public static void kad(int numbers[])
+    {
+        int cs=0;
+        int ms=Integer.MIN_VALUE;
+        for(int i=0; i<numbers.length;i++){
+            cs += numbers[i];
+            if(cs<0){
+                cs=0;
+            }
+            ms=Math.max(cs,ms);
+
+        }
+
+        System.out.print("maxsubarray sum is :" + ms);
+    }
+    public static void main(String args[]){
+        int numbers[] = {-2,-3,4,-1,-2,1,5,-3};
+        kad(numbers);
+    }
+}

JAVA/DSA in java/largest.java

@@ -0,0 +1,20 @@
+import java.util.*;
+public class largest {
+    public static int getlargest(int numbers[]){
+        int largest = Integer.MIN_VALUE;
+        for(int i =0;i<numbers.length;i++){
+            if(largest<numbers[i]){
+
+                largest=numbers[i];
+            }
+        }
+        return largest;
+
+    }
+    public static void main(String args[]){
+        int numbers[] = {1,2,6,3,5};
+        System.out.println("nu is largest : " + getlargest(numbers));
+
+
+    }
+}

JAVA/DSA in java/prefix.java

@@ -0,0 +1,32 @@
+public class prefix {
+    public static void maxsub(int numbers[])
+    {
+        int currsum=0;
+        int maxsum=Integer.MIN_VALUE;
+        int prefix[]=new int[numbers.length];
+        prefix[0]=numbers[0];
+        for(int i=1; i<prefix.length;i++){
+            prefix[i]=prefix[i-1]+numbers[i];
+        }
+
+        for(int i =0;i<numbers.length;i++){
+            int start=i;
+            for(int j=i;j<numbers.length;j++){
+                int end=j;
+                currsum = start ==0?prefix[end]:prefix[end]-prefix[start-1];
+
+
+                    if(maxsum<currsum){
+                        maxsum=currsum;
+                    }
+
+            }
+
+        }
+        System.out.print("maxsum" +  maxsum);
+    }
+    public static void main(String args[]){
+        int numbers[] = {1,-2,6,-1,3};
+        maxsub(numbers);
+    }
+}

JAVA/DSA in java/sorting/bubblesort.java

@@ -0,0 +1,27 @@
+public class bubblesort {
+    public static void bub(int arr[])
+    {
+        for(int turn=0;turn<arr.length;turn++){
+            for(int j=0;j<arr.length-1-turn;j++){
+                if(arr[j]>arr[j+1]){
+                    int temp=arr[j];
+                    arr[j]=arr[j+1];
+                    arr[j+1]=temp;
+                }
+            }
+        }
+    }
+    public static void printarr(int arr[]){
+        for(int i=0;i<arr.length;i++){
+            System.out.print(arr[i]+" ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String args[]){
+    int arr[] = {1,4,1,3,2,4,3,7};
+
+    bub(arr);
+    printarr(arr);
+    }
+}

JAVA/DSA in java/sorting/countingsort.java

@@ -0,0 +1,36 @@
+public class countingsort {
+    public static void printarr(int arr[]){
+        for(int i=0;i<arr.length;i++){
+            System.out.print(arr[i]+" ");
+        }
+        System.out.println();
+    }
+
+    public static void count(int arr[]){
+        int largest=Integer.MIN_VALUE;
+    for(int i=0;i<arr.length;i++){
+        largest=Math.max(largest,arr[i]);
+    }
+             int count[]=new int[largest+1];
+             for(int i=0;i<arr.length;i++){
+                count[arr[i]]++;
+             }
+             //sorting
+             int j=0;
+             for(int i=0;i<count.length;i++){
+                while(count[i]>0){
+                    arr[j]=i;
+                    j++;
+                    count[i]--;
+                }
+
+             }
+    }
+
+        public static void main(String args[]){
+        int arr[] = {1,4,1,3,2,4,3,7};
+
+        count(arr);
+        printarr(arr);
+        }
+}

JAVA/DSA in java/sorting/insertionsort.java

@@ -0,0 +1,26 @@
+public class insertionsort {
+    public static void printarr(int arr[]){
+        for(int i=0;i<arr.length;i++){
+            System.out.print(arr[i]+" ");
+        }
+        System.out.println();
+    }
+
+public static void insertion(int arr[]){
+    for(int i=1;i<arr.length;i++){
+        int curr=arr[i];
+        int prev=i-1;
+        while(prev>=0 && arr[prev]>curr){
+            arr[prev+1]=arr[prev];
+            prev--;
+        }
+        //insertion
+        arr[prev+1]=curr;
+     }
+}
+    public static void main(String args[]){
+    int arr[] = {1,4,1,3,2,4,3,7};
+    insertion(arr);
+    printarr(arr);
+    }
+}

JAVA/DSA in java/sorting/selectionsort.java

@@ -0,0 +1,27 @@
+public class selectionsort {
+    public static void printarr(int arr[]){
+        for(int i=0;i<arr.length;i++){
+            System.out.print(arr[i]+" ");
+        }
+        System.out.println();
+    }
+    public static void select(int arr[]){
+        for(int i=0;i<arr.length-1;i++){
+            int minpos=i;
+            for(int j=i+1;j<arr.length;j++){
+                if(arr[minpos]>arr[j]){
+                    minpos=j;
+                }
+            }
+            int temp=arr[minpos];
+                    arr[minpos]=arr[i];
+                    arr[i]=temp;
+        }
+}
+    public static void main(String args[]){
+    int arr[] = {1,4,1,3,2,4,3,7};
+    select(arr);
+
+    printarr(arr);
+    }
+}

JAVA/DSA in java/spiralmatrix.java

@@ -0,0 +1,48 @@
+public class spiralmatrix {
+    public static void printspiral(int matrix[][]){
+        int startrow=0;
+        int endrow=matrix.length-1;
+        int startcol=0;
+        int endcol=matrix[0].length-1;
+
+        while(startrow<=endrow && startcol<=endcol){
+            //top
+            for(int j=startcol;j<=endcol;j++){
+                System.out.print(matrix[startrow][j]+ " ");
+            }
+
+            //right
+            for(int i=startrow+1;i<=endrow;i++){
+                System.out.print(matrix[i][endcol]+ " ");
+            }
+
+                //bottom
+                for(int j=endcol-1;j>=startcol;j--){
+                    if(startrow==endrow){
+                        break;
+                    }
+                    System.out.print(matrix[endrow][j] + " ");
+                }
+
+                //left
+                for(int i=endrow-1;i>=startrow+1;i--){
+                    if(startcol==endcol){
+                        break;
+                    }
+                    System.out.print(matrix[i][startcol]+ " ");
+                }
+                startcol++;
+                startrow++;
+                endrow--;
+                endcol--;
+            }
+            System.out.println();
+        }
+    public static void main(string args[]){
+        int matrix[][]={{1,2,3,4},
+                       {5,6,7,8},
+                       {9,10,11,12},
+                       {13,14,15,16}};
+        printspiral(matrix);
+    }
+}

JAVA/DSA in java/trap.java

@@ -0,0 +1,32 @@
+public class trap {
+    public static int Rainwater(int height[]){
+        int n=height.length;
+        //calculate left max boundary -array
+        int leftmax[]= new int[n];
+        leftmax[0]=height[0];
+        for(int i=1; i<n; i++){
+            leftmax[i]=Math.max(height[i],leftmax[i-1]);
+         }
+        //calculate right max boundary -array
+        int rightmax[]= new int[n];
+        rightmax[n-1]=height[n-1];
+        for(int i=n-2;i>=0;i--){
+            rightmax[i]=Math.max(height[i],leftmax[i+1]);
+        }
+        int trappedwat=0;
+
+        //loop
+        for(int i=0;i<n;i++){
+            //water = min(left max bound,right max bound)
+           int watlevel= Math.min(leftmax[i],rightmax[i]);
+           //trapped water = water - height[i]
+           trappedwat += watlevel-height[i];
+    }
+    return trappedwat;
+        }
+        public static void main(String args[]){
+        int height[]={4,2,0,6,3,2,5};
+        System.out.println(Rainwater(height));
+    } 
+}
+