From 6806203c4f01f30a18a67b713c97ecc5b2af599f Mon Sep 17 00:00:00 2001 From: RishabhSrivastava1423 <65828863+RishabhSrivastava1423@users.noreply.github.com> Date: Mon, 10 Oct 2022 13:43:32 +0530 Subject: [PATCH 1/3] Quick Sort algorithm in JAVA added --- Java/Sorting/QuickSort.java | 78 +++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 Java/Sorting/QuickSort.java diff --git a/Java/Sorting/QuickSort.java b/Java/Sorting/QuickSort.java new file mode 100644 index 0000000..caecc0c --- /dev/null +++ b/Java/Sorting/QuickSort.java @@ -0,0 +1,78 @@ +/** + * + * 1. Quick Sort is an inplace sorting algorithm based on Divide and Conquer Approach. + * 2. First a pivot element is choosen and partitions are made around the choosen pivot. + * 3. Selection of pivot element decides the time complexity of algorithm. + * + */ + +package Java.Sorting; + +import java.util.*; +public class QuickSort { + static void swap(int[] arr, int i, int j) + { + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } + + static int partition(int[] arr, int low, int high) + { + int pivot = arr[high]; + int i = (low - 1); + + for (int j = low; j <= high - 1; j++) { + if (arr[j] < pivot) { + i++; + swap(arr, i, j); + } + } + swap(arr, i + 1, high); + return (i + 1); + } + + static void quickSort(int[] arr, int low, int high) + { + if (low < high) { + int pi = partition(arr, low, high); + quickSort(arr, low, pi - 1); + quickSort(arr, pi + 1, high); + } + } + + static void printArray(int[] arr, int size) + { + for (int i = 0; i < size; i++) + System.out.print(arr[i] + " "); + + System.out.println(); + } + + public static void main(String[] args) + { + Scanner scan = new Scanner(System.in); + int n = scan.nextInt(); + + int[] arr = new int[n]; + for(int i=0;i Date: Mon, 10 Oct 2022 14:22:02 +0530 Subject: [PATCH 2/3] Longest Common Subsequence(LCS) added in JAVA --- .../LongestCommonSubsequence.java | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 Java/Dynamic_Programming/LongestCommonSubsequence.java diff --git a/Java/Dynamic_Programming/LongestCommonSubsequence.java b/Java/Dynamic_Programming/LongestCommonSubsequence.java new file mode 100644 index 0000000..115b405 --- /dev/null +++ b/Java/Dynamic_Programming/LongestCommonSubsequence.java @@ -0,0 +1,54 @@ +package Java.Dynamic_Programming; +import java.util.*; +public class LongestCommonSubsequence { + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + + String a = scan.next(); + String b = scan.next(); + + int m = a.length(); + int n = b.length(); + + LongestCommonSubsequence lcs = new LongestCommonSubsequence(); + lcs.getLCS(a,b,m,n); + + scan.close(); + } + private void getLCS(String a, String b, int m, int n) { + int dp[][] = new int[m+1][n+1]; + for(int i=0;i<=m;i++){ + for(int j=0;j<=n;j++){ + if(i==0 || j==0){ + dp[i][j] = 0; + } + else if(a.charAt(i-1) == b.charAt(j-1)){ + dp[i][j] = 1 + dp[i-1][j-1]; + } + else{ + dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]); + } + } + } + int len = dp[m][n]; + + String res = ""; + int i = m; + int j = n; + while (i > 0 && j > 0) { + if (a.charAt(i - 1) == b.charAt(j - 1)) { + res += Character.toString(a.charAt(i - 1)); + i--; + j--; + } + + else if (dp[i - 1][j] > dp[i][j - 1]) + i--; + else + j--; + } + System.out.println("Length of lCS is : "+ len); + System.out.println("LCS string is : "+ new StringBuilder(res).reverse().toString()); + } +} From 5b9e01eb3a038c55b2843929dea5589645467433 Mon Sep 17 00:00:00 2001 From: RishabhSrivastava1423 <65828863+RishabhSrivastava1423@users.noreply.github.com> Date: Mon, 10 Oct 2022 14:30:36 +0530 Subject: [PATCH 3/3] Longest Palindromic Subsequence --- .../LongestPalindromicSubsequence.java | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 Java/Dynamic_Programming/LongestPalindromicSubsequence.java diff --git a/Java/Dynamic_Programming/LongestPalindromicSubsequence.java b/Java/Dynamic_Programming/LongestPalindromicSubsequence.java new file mode 100644 index 0000000..4213c61 --- /dev/null +++ b/Java/Dynamic_Programming/LongestPalindromicSubsequence.java @@ -0,0 +1,52 @@ +package Java.Dynamic_Programming; +import java.util.*; +public class LongestPalindromicSubsequence { + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + + String a = scan.next(); + int m = a.length(); + + LongestPalindromicSubsequence lps = new LongestPalindromicSubsequence(); + lps.getLPS(a,m); + + scan.close(); + } + private void getLPS(String a,int m) { + String b = new StringBuilder(a).reverse().toString(); + + int dp[][] = new int[m+1][m+1]; + for(int i=0;i<=m;i++){ + for(int j=0;j<=m;j++){ + if(i==0 || j==0){ + dp[i][j] = 0; + } + else if(a.charAt(i-1) == b.charAt(j-1)){ + dp[i][j] = 1 + dp[i-1][j-1]; + } + else{ + dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]); + } + } + } + int len = dp[m][m]; + + String res = ""; + int i = m; + int j = m; + while (i > 0 && j > 0) { + if (a.charAt(i - 1) == b.charAt(j - 1)) { + res += Character.toString(a.charAt(i - 1)); + i--; + j--; + } + + else if (dp[i - 1][j] > dp[i][j - 1]) + i--; + else + j--; + } + System.out.println("Length of LPS is : "+ len); + System.out.println("LPS string is : "+ new StringBuilder(res).reverse().toString()); + } +}