From 1bd90983a840c3f0533e8a9be73a72364b370e83 Mon Sep 17 00:00:00 2001
From: BHAVIK <bhavikprajapati4244@gmail.com>
Date: Thu, 28 Sep 2023 14:35:55 +0530
Subject: [PATCH] issue-#6 added some java dsa programs with optimal solution

---
 LeetCode/ShiftByK.java     |  40 +++++++++
 LeetCode/Sort012.java      |  61 +++++++++++++
 LeetCode/Sortings.java     | 169 +++++++++++++++++++++++++++++++++++++
 LeetCode/SpiralMatrix.java |  68 +++++++++++++++
 4 files changed, 338 insertions(+)
 create mode 100644 LeetCode/ShiftByK.java
 create mode 100644 LeetCode/Sort012.java
 create mode 100644 LeetCode/Sortings.java
 create mode 100644 LeetCode/SpiralMatrix.java

diff --git a/LeetCode/ShiftByK.java b/LeetCode/ShiftByK.java
new file mode 100644
index 00000000..b9b9db43
--- /dev/null
+++ b/LeetCode/ShiftByK.java
@@ -0,0 +1,40 @@
+package LEasy;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class ShiftByK {
+    public static void main(String[] args) {
+
+        int[] arr={1,2,3,4,5};
+        int n=arr.length;
+        ArrayList<Integer> temp1=new ArrayList<>();
+
+        int k=2;
+
+        for (int i = k; i < n; i++) {
+            temp1.add(arr[i]);
+        }
+        for (int i = 0; i < k; i++) {
+            temp1.add(arr[i]);
+        }
+
+        for (int i = 0; i < arr.length; i++) {
+            arr[i]=temp1.get(i);
+        }
+        System.out.println(Arrays.toString(arr));
+
+
+
+
+
+
+
+
+
+
+
+
+    }
+
+}
diff --git a/LeetCode/Sort012.java b/LeetCode/Sort012.java
new file mode 100644
index 00000000..151f8a5e
--- /dev/null
+++ b/LeetCode/Sort012.java
@@ -0,0 +1,61 @@
+package LEasy;
+
+
+import java.util.Arrays;
+
+public class Sort012 {
+
+    static class Node{
+        int data;
+        Node next;
+
+        Node(int data){
+            this.data=data;
+            this.next=null;
+        }
+    }
+
+
+    public static void main(String[] args) {
+        int[] arr={0,1,2,0,1,2,1,2,0,0,0,1};
+//        int n=arr.length;
+
+//        bruteforce(mergesort);
+
+        optimal(arr);
+
+
+
+
+    }
+
+    private static void optimal(int[] arr) {
+        int low=0;
+        int mid=0;
+        int high=arr.length-1;
+        while (mid<=high){
+            if(arr[mid]==0){
+                int temp=arr[low];
+                arr[low]=arr[mid];
+                arr[mid]=temp;
+                low++;
+                mid++;
+            }else if(arr[mid]==1){
+                mid++;
+            }else{
+                int temp=arr[mid];
+                arr[mid]=arr[high];
+                arr[high]=temp;
+                high--;
+            }
+        }
+
+
+        System.out.println(Arrays.toString(arr));
+
+    }
+
+
+
+
+}
diff --git a/LeetCode/Sortings.java b/LeetCode/Sortings.java
new file mode 100644
index 00000000..c8f6d3aa
--- /dev/null
+++ b/LeetCode/Sortings.java
@@ -0,0 +1,169 @@
+package LEasy;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class Sortings {
+    public static void main(String[] args) {
+        int[] arr={ 5,4,3,2,1};
+        int n=arr.length;
+//        sorting(arr,n);
+
+//        bubblesort(arr,n);
+//        insertionsort(arr,n);
+//        mergesort(arr,0,n-1);
+        quicksort(arr,0,n-1);
+        System.out.println(Arrays.toString(arr));
+//        System.out.println(Arrays.toString(arr));
+
+
+
+    }
+
+    private static void quicksort(int[] arr, int low, int high) {
+
+        if(low<high){
+            int pidx=partition(arr,low,high);
+            quicksort(arr,low,pidx-1);
+            quicksort(arr,pidx+1,high);
+        }
+    }
+
+    private static int partition(int[] arr, int low, int high) {
+
+        int pivot=arr[low];
+        int i=low;
+        int j=high;
+
+        while (i<j){
+            while (arr[i]<=pivot && i<=high-1){
+                i++;
+            }
+
+            while (arr[j]>pivot && j>=low+1){
+                j--;
+            }
+            if(i<j){
+                int temp=arr[i];
+                arr[i]=arr[j];
+                arr[j]=temp;
+            }
+
+        }
+        int temp=arr[low];
+        arr[low]=arr[j];
+        arr[j]=temp;
+
+        return j;
+
+    }
+
+    private static void mergesort(int[] arr, int low,int high) {
+        if(low>=high){
+            return;
+        }
+//        int mid=(low+high)/2;
+        int mid=low+(high-low)/2;
+        mergesort(arr,low,mid);
+        mergesort(arr,mid+1,high);
+        merge(arr,low,mid,high);
+
+
+
+
+
+
+    }
+
+
+    private static void merge(int[] arr, int low, int mid, int high) {
+
+        ArrayList<Integer> temp=new ArrayList<>();
+        int left=low;
+        int right=mid+1;
+
+        while (left<=mid && right<=high){
+
+            if (arr[left]<=arr[right]){
+
+                temp.add(arr[left]);
+                left++;
+
+            }else{
+                temp.add(arr[right]);
+                right++;
+            }
+        }
+
+
+        while (left<=mid){
+            temp.add(arr[left]);
+            left++;
+        }
+
+        while (right<=high){
+            temp.add(arr[right]);
+            right++;
+        }
+
+
+        for (int i = low; i <= high; i++) {
+            arr[i] = temp.get(i - low);
+        }
+
+    }
+
+    private static void insertionsort(int[] arr, int n) {
+        for (int i = 0; i <=n-1; i++) {
+            int j=i;
+            while (j>0 && arr[j-1]>arr[j]){
+                int temp=arr[j-1];
+                arr[j-1]=arr[j];
+                arr[j]=temp;
+                j--;
+            }
+
+        }
+
+    }
+
+    private static void bubblesort(int[] arr, int n) {
+
+        boolean swapped=false;
+        for (int i = 0; i < n-1; i++) {
+
+            swapped=false;
+            for (int j = 0; j < n-i-1; j++) {
+                if(arr[j]>arr[j+1]){
+                    int temp=arr[j];
+                    arr[j]=arr[j+1];
+                    arr[j+1]=temp;
+                    swapped=true;
+                }
+                
+            }
+            if(swapped==false){
+                break;
+            }
+                
+
+            
+        }
+        
+    }
+
+    private static void sorting(int[] arr, int n) {
+        for (int i = 0; i < n-1; i++) {
+
+            int min=i;
+            for (int j = i+1; j < n; j++) {
+                if(arr[j]<arr[min]){
+                    min=j;
+                }
+            }
+            int temp=arr[min];
+            arr[min]=arr[i];
+            arr[i]=temp;
+        }
+    }
+}
diff --git a/LeetCode/SpiralMatrix.java b/LeetCode/SpiralMatrix.java
new file mode 100644
index 00000000..17f9261b
--- /dev/null
+++ b/LeetCode/SpiralMatrix.java
@@ -0,0 +1,68 @@
+package LEasy;
+
+public class SpiralMatrix {
+    public static void main(String[] args) {
+        int[][] arr={
+                {1,2,3,4,5,6},
+                {20,21,22,23,24,7},
+                {19,32,33,34,25,8},
+                {18,31,36,35,26,9},
+                {17,30,29,28,27,10},
+                {16,15,14,13,12,11},
+        };
+
+        int n=arr.length;//rows
+        int m=arr[0].length;//cols
+
+
+
+        int left=0,right=m-1, top=0,bottom=n-1;
+
+        while (top<=bottom && left<=right){
+
+
+        for (int i = left; i <=right ; i++) {
+            System.out.print(arr[top][i]+" ");
+        }
+        top++;
+
+        for (int i = top; i <=bottom ; i++) {
+            System.out.print(arr[i][right]+" ");
+        }
+
+        right--;
+
+
+        for (int i = right; i >=left ; i--) {
+            System.out.print(arr[bottom][i]+" ");
+        }
+        bottom--;
+
+
+        for (int i = bottom; i >=top ; i--) {
+            System.out.print(arr[i][left]+" ");
+        }
+        left++;
+
+        }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    }
+}