sorting and few other data structure programs

Author: jbhattac

MergeNSortedArrays.java

@@ -0,0 +1,61 @@
+package ds.algo.solutions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MergeNSortedArrays {
+
+	public static void main(String[] args) {
+		int[] arr1 = new int[] {1, 5, 9, 10, 90, 91};
+		int[] arr2 = new int[] {2, 6, 11, 50, 51};
+		int[] arr3 = new int[] {3, 7, 18, 19};
+		int[] arr4 = new int[] {4, 8, 30, 35};
+		int[] arr5 = new int[] {};
+		
+		int[] res = new MergeNSortedArrays().mergeNArrays(arr1, arr2, arr3, arr4, arr5);
+		for (int i : res) {
+			System.out.println(i);
+		}
+	}
+	
+	public int[] mergeNArrays(int[]...arrays) {
+		
+		int totalLen = 0;
+		List<Integer> counters = new ArrayList<>();
+		
+		for (int[] array : arrays) {
+			totalLen += array.length;
+			counters.add(0);
+		}
+		
+		int[] resultArr = new int[totalLen];
+		int index = 0;
+		
+		while(index < totalLen) {
+			resultArr[index++] = getMin(arrays, counters);
+		}
+		
+		return resultArr;
+	}
+
+	private int getMin(int[][] arrays, List<Integer> counters) {
+		int min = Integer.MAX_VALUE;
+		int val, index;
+		int arrayIndex = -1;
+		
+		for (int i = 0; i < arrays.length; i++) {
+			index = counters.get(i);
+			if (index > arrays[i].length - 1) {
+				continue;
+			}
+			val = arrays[i][index];
+			if (val < min) {
+				min = val;
+				arrayIndex = i;
+			}
+		}
+		counters.set(arrayIndex, counters.get(arrayIndex) + 1);
+		
+		return min;
+	}
+}

MergeSort.java

@@ -0,0 +1,60 @@
+package ds.algo.solutions;
+
+import java.util.stream.Stream;
+
+public class MergeSort {
+	
+	public void mergeSort(Integer[] integers, int l, int r) {
+		if (l < r) {
+			int m = (l + r) / 2;
+			mergeSort(integers, l, m);
+			mergeSort(integers, m + 1, r);
+
+			merge(integers, l, m, r);
+		}
+	}
+
+	private void merge(Integer[] integers, int l, int m, int r) {
+		int n1 = m - l + 1;
+		int n2 = r - m;
+
+		int[] L = new int[n1];
+		int[] R = new int[n2];
+
+		for (int i = 0; i < n1; i++) {
+			L[i] = integers[l + i];
+		}
+
+		for (int i = 0; i < n2; i++) {
+			R[i] = integers[m + 1 + i];
+		}
+
+		int i = 0, j = 0;
+		int k = l;
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				integers[k++] = L[i++];
+			} else {
+				integers[k++] = R[j++];
+			}
+		}
+
+		/* Copy remaining elements of L[] if any */
+		while (i < n1) {
+			integers[k++] = L[i++];
+		}
+
+		/* Copy remaining elements of R[] if any */
+		while (j < n2) {
+			integers[k++] = R[j++];
+		}
+
+	}
+
+	public static void main(String[] args) {
+		Integer[] arr = new Integer[] {0, 9, 7, 6, 1, 3, 5, 2, 4, 8};
+		new MergeSort().mergeSort(arr, 0, arr.length - 1);
+		Stream.of(arr).forEach(System.out::println);
+	}
+	
+}

QuickSort.java

@@ -0,0 +1,43 @@
+package ds.algo.solutions;
+
+import java.util.stream.Stream;
+
+public class QuickSort {
+
+	public void quickSort(Integer[] integers, int low, int high) {
+
+		if (low < high) {
+			int pi = partition(integers, high, low);
+
+			quickSort(integers, low, pi - 1);
+			quickSort(integers, pi + 1, high);
+		}
+	}
+
+	private int partition(Integer[] integers, int high, int low) {
+		int pivot = high;
+		int i = low - 1;
+		int temp;
+
+		for (int j = low; j < pivot; j++) {
+			if (integers[j] < integers[pivot]) {
+				i++;
+				temp = integers[i];
+				integers[i] = integers[j];
+				integers[j] = temp;
+			}
+		}
+
+		temp = integers[i + 1];
+		integers[i + 1] = integers[pivot];
+		integers[pivot] = temp;
+
+		return i + 1;
+	}
+	
+	public static void main(String[] args) {
+		Integer[] arr = new Integer[] {0, 9, 7, 6, 1, 3, 5, 2, 4, 8};
+		new QuickSort().quickSort(arr, 0, arr.length - 1);
+		Stream.of(arr).forEach(System.out::println);
+	}
+}

RemoveAllSpacesInplace.java

@@ -0,0 +1,43 @@
+package ds.algo.solutions;
+
+public class RemoveAllSpacesInplace {
+
+	public static void main(String[] args) {
+		String str = " h e        llo wor ld    ";
+		
+		char[] ch = str.toCharArray();
+		System.out.println("Before");
+		System.out.println(ch);
+		boolean spaceFlag = false;
+		int pos = 0;
+		int spaceCounter = 0;
+		
+		for (int i = 0; i < ch.length; i++) {
+			if (ch[i] == ' ') {
+				spaceCounter++;
+			}
+			if (ch[i] == ' ' && !spaceFlag) {
+				pos = i;
+				spaceFlag = true;
+			}
+			else if (ch[i] != ' ' && spaceFlag) {
+				spaceFlag = false;
+				for (int j = i; j < ch.length; j++) {
+					ch[pos++] = ch[j];
+				}
+				i = i - spaceCounter;
+				
+				// remove the trailing character
+				for (int k = 0; k < spaceCounter; k++) {
+					ch[ch.length - 1 - k] = ' ';
+				}
+				
+				spaceCounter = 0;
+			}
+		}
+		
+		
+		System.out.println("After");
+		System.out.println(ch);
+	}
+}