Update: added Object and reverse ordering

kdgyun · kdgyun · commit df875ee6f4cd · 2021-08-02T20:29:48.000+09:00
diff --git a/SortingAlgorithm/Java/BinaryInsertionSort/BinaryInsertionSort.java b/SortingAlgorithm/Java/BinaryInsertionSort/BinaryInsertionSort.java
@@ -1,5 +1,10 @@
 package BinaryInsertionSort;
 
+import java.util.Comparator;
+
+import Utils.Convert;
+import Utils.Order;
+
 /**
  * 
  * @author kdgyun
@@ -625,5 +630,257 @@ private static void reversing(double[] a, int lo, int hi) {
 			a[hi--] = temp;
 		}
 	}
+	
+	
+	
+	
+	/*==========================
+	 * sorting Object type array 
+	 *==========================*/
+	
+	public static <T> void sort(T[] a, Comparator<? super T> c) {
+		
+		if(c == null) {
+			sort(a);
+		}
+		else {
+			if(a.length < 2) {
+				return;
+			}
+			int incLength = getAscending(a, 0, a.length, c);
+			ComparatorSort(a, 0, a.length, incLength, c);
+			
+		}
+	}
+	
+	// Comparable sort
+	public static void sort(Object[] a) {
+		if(a.length < 2) {
+			return;
+		}
+		int incLength = getAscending(a, 0, a.length);
+		ComparableSort(a, 0, a.length, incLength);
+	}
+	
+	private static void ComparableSort(Object[] a, int lo, int hi, int start) {
+		if(lo == start) {
+			start++;
+		}
+
+		for (; start < hi; start++) {
+			@SuppressWarnings("rawtypes")
+			Comparable target = (Comparable)a[start];
+
+			int loc = binarySearch(a, target, 0, start);
+
+			int j = start - 1;
+
+			while (j >= loc) {
+				a[j + 1] = a[j];
+				j--;
+			}
+
+			a[loc] = target;
+		}
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	private static int binarySearch(Object[] a, Comparable key, int lo, int hi) {
+
+		int mid;
+		while (lo < hi) {
+			mid = (lo + hi) >>> 1;
+			if (key.compareTo(a[mid]) < 0) {
+				hi = mid;
+			} 
+			else {
+				lo = mid + 1;
+			}
+		}
+		return lo;
+	}
+	
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private static int getAscending(Object[] a, int lo, int hi) {	
+
+		int limit = lo + 1;
+		if (limit == hi) { 
+			return 1;
+		}
+
+		if (((Comparable)a[lo]).compareTo(a[limit]) <= 0) {
+			while (limit < hi && ((Comparable)a[limit - 1]).compareTo(a[limit]) <= 0) {
+				limit++;
+			}
+		}
+		else {
+			while (limit < hi && ((Comparable)a[limit - 1]).compareTo(a[limit]) > 0) {
+				limit++;
+			}
+			reversing(a, lo, limit);
+		}
+
+		return limit - lo;
+	}
+	
+
+    
+    
+    // Comparator sort
+    private static <T> void ComparatorSort(T[] a, int lo, int hi, int start, Comparator<? super T> c) {
+		if(lo == start) {
+			start++;
+		}
+
+		for (; start < hi; start++) {
+			T target = a[start];
+
+			int loc = binarySearch(a, target, 0, start, c);
+
+			int j = start - 1;
+
+			while (j >= loc) {
+				a[j + 1] = a[j];
+				j--;
+			}
+
+			a[loc] = target;
+		}
+	}
+
+	private static <T> int binarySearch(T[] a, T key, int lo, int hi, Comparator<? super T> c) {
+
+		int mid;
+		while (lo < hi) {
+			mid = (lo + hi) >>> 1;
+			if (c.compare(key, a[mid]) < 0) {
+				hi = mid;
+			} 
+			else {
+				lo = mid + 1;
+			}
+		}
+		return lo;
+	}
+	
+	private static <T> int getAscending(T[] a, int lo, int hi, Comparator<? super T> c) {	
+
+		int limit = lo + 1;
+		if (limit == hi) { 
+			return 1;
+		}
+
+		if (c.compare(a[lo], a[limit]) <= 0) {
+			while (limit < hi && c.compare(a[limit - 1], a[limit]) <= 0) {
+				limit++;
+			}
+		}
+		else {
+			while (limit < hi && c.compare(a[limit - 1], a[limit]) > 0) {
+				limit++;
+			}
+			reversing(a, lo, limit);
+		}
+
+		return limit - lo;
+	}
+	
+	
+    private static <T> void reversing(T[] a, int lo, int hi) {
+    	hi--;
+        while (lo < hi) {
+        	T temp = a[lo];
+            a[lo++] = a[hi];
+            a[hi--] = temp;
+        }
+    }
+    
+    
+    
+	/*
+	 * ========================== 
+	 *  reverse ordering
+	 * ==========================
+	 */
+	
+	
+	public static void sort(byte[] a, boolean isReverse) {
+		if(isReverse) {
+			Byte[] b = Convert.toByteArray(a);
+			sort(b, Order.reverseOrder());
+			Convert.tobyteArray(b, a);
+		}
+		else {
+			sort(a);
+		}
+	}
+	
+	public static void sort(char[] a, boolean isReverse) {
+		if(isReverse) {
+			Character[] b = Convert.toCharacterArray(a);
+			sort(b, Order.reverseOrder());
+			Convert.tocharArray(b, a);
+		}
+		else {
+			sort(a);
+		}
+	}
+	
+	public static void sort(short[] a, boolean isReverse) {
+		if(isReverse) {
+			Short[] b = Convert.toShortArray(a);
+			sort(b, Order.reverseOrder());
+			Convert.toshortArray(b, a);
+		}
+		else {
+			sort(a);
+		}
+	}
+	
+	public static void sort(int[] a, boolean isReverse) {
+		if(isReverse) {
+			Integer[] b = Convert.toIntegerArray(a);
+			sort(b, Order.reverseOrder());
+			Convert.tointtArray(b, a);
+		}
+		else {
+			sort(a);
+		}
+	}
+	
+	
+	public static void sort(long[] a, boolean isReverse) {
+		if(isReverse) {
+			Long[] b = Convert.toLongArray(a);
+			sort(b, Order.reverseOrder());
+			Convert.tolongArray(b, a);
+		}
+		else {
+			sort(a);
+		}
+	}
+	
+	public static void sort(float[] a, boolean isReverse) {
+		if(isReverse) {
+			Float[] b = Convert.toFloatArray(a);
+			sort(b, Order.reverseOrder());
+			Convert.toflostArray(b, a);
+		}
+		else {
+			sort(a);
+		}
+	}
+	
+	public static void sort(double[] a, boolean isReverse) {
+		if(isReverse) {
+			Double[] b = Convert.toDoubleArray(a);
+			sort(b, Order.reverseOrder());
+			Convert.todoubleArray(b, a);
+		}
+		else {
+			sort(a);
+		}
+	}
+
 }
 
