mergeSort & bubbleSort added

src/algorithm/AlgoTest.java

@@ -1,44 +1,39 @@
 package algorithm;
 
+import java.util.Arrays;
+
 public class AlgoTest {
 
-	public static final int N = 2000;
+	public static final int N = 50000;
 	public static final int RANGE_R = 20;
 	public static final int RANGE_L = 400;
 	public static final int MAX_OF_STUDENT_NUM = 2000;
 
-	public static final String AFTER_TEXT = "\n after : ";
+	public static final String CLASS_NAME = "algorithm.Sort";
 
-	public static void testSelectionSort() {
-		Integer[] arr = new Integer[N];
-		arr = SortTestHelper.generateRandomArray(N, RANGE_R, RANGE_L);
-		SortTestHelper.printArray(arr);
-		System.out.println(AFTER_TEXT);
-		Sort.selectSort(arr);
-		SortTestHelper.printArray(arr);
+	public AlgoTest() {
+		// Integer[] arr = SortTestHelper.generateNearlyOrderedArray(N, 100);
+		Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 400);
+		handleSort(Sort.INSERT_SORT, arr.clone());
+		handleSort(Sort.INSERT_SORT_AD, arr.clone());
+		handleSort(Sort.BUBBLE_SORT, arr.clone());
+		// handleSort(Sort.BUBBLE_SORT_AD_V1, arr.clone());
+		// handleSort(Sort.BUBBLE_SORT_AD_V3, arr.clone());
+		handleSort(Sort.MERGE_SORT, arr.clone());
+		handleSort(Sort.SELECT_SORT, arr.clone());
 	}
 
-	public static void testBubbleSort() {
-		Integer[] arr = new Integer[N];
-		arr = SortTestHelper.generateRandomArray(N, RANGE_R, RANGE_L);
-		SortTestHelper.printArray(arr);
-		Sort.bubbleSort(arr);
-		SortTestHelper.printArray(arr);
+	private static <T extends Comparable> void handleSort(String sortName, T[] arr) {
+		new Thread(new Runnable() {
+			@Override
+			public void run() {
+				SortTestHelper.testSort(sortName, CLASS_NAME, arr);
+			}
+		}).start();
 	}
-	
+
 	public static void main(String[] args) {
-		// testSelectionSort();
-		// Student[] ss = Student.generateStudentArray(N, MAX_OF_STUDENT_NUM);
-//		Integer[] arr = SortTestHelper.generateRandomArray(N, RANGE_R, RANGE_L);
-//		Sort.insertSort(arr);
-//		SortTestHelper.printArray(arr);
-//		System.out.println(SortTestHelper.isSorted(arr));
-//		
-//		
-		testBubbleSort();
+		new AlgoTest();
 	}
-
-
-}
-
 
+}

src/algorithm/Sort.java

@@ -1,7 +1,18 @@
 package algorithm;
 
+import java.util.Arrays;
+
 public class Sort {
 
+	public static final String SELECT_SORT = "selectSort";
+	public static final String INSERT_SORT = "insertSort";
+	public static final String INSERT_SORT_AD = "insertSortImproved";
+	public static final String BUBBLE_SORT = "bubbleSort";
+	public static final String BUBBLE_SORT_AD_V1 = "bubbleSortImprovedV1";
+	public static final String BUBBLE_SORT_AD_V2 = "bubbleSortImprovedV2";
+	public static final String BUBBLE_SORT_AD_V3 = "bubbleSortImprovedV3";
+	public static final String MERGE_SORT = "mergeSort";
+
 	private Sort() {
 	}
 
@@ -30,17 +41,28 @@ public static <T extends Comparable> void selectSort(T[] arr) {
 	 * 
 	 * 对近乎有序的数组的排序效率非常高
 	 * 
+	 * 原始方法 多次交换，浪费时间
 	 */
 	public static <T extends Comparable> void insertSort(T[] arr) {
 		for (int i = 1; i < arr.length; i++) {
-			// 原始方法 多次交换，浪费时间
-			// for (int j = i; j > 0 && arr[j].compareTo(arr[j - 1]) < 0; j--) {
-			// // 右边比左边小，则交换
-			// T temp = arr[j];
-			// arr[j] = arr[j - 1];
-			// arr[j - 1] = temp;
-			// }
-			// 优化后的方法 大量减少交换
+
+			for (int j = i; j > 0 && arr[j].compareTo(arr[j - 1]) < 0; j--) {
+				// 右边比左边小，则交换
+				T temp = arr[j];
+				arr[j] = arr[j - 1];
+				arr[j - 1] = temp;
+			}
+
+		}
+	}
+
+	/*
+	 * 改进插入排序
+	 *
+	 * 优化后的方法 大量减少交换
+	 */
+	public static <T extends Comparable> void insertSortImproved(T[] arr) {
+		for (int i = 0; i < arr.length; i++) {
 			int j = i;// i元素最终要插入的位置
 			T temp = arr[i];
 			for (; j > 0 && arr[j - 1].compareTo(temp) > 0; j--) {
@@ -52,11 +74,12 @@ public static <T extends Comparable> void insertSort(T[] arr) {
 
 	/*
 	 * 基本冒泡排序
+	 * 
 	 */
 	public static <T extends Comparable> void bubbleSort(T[] arr) {
 
-		for (int i = 1; i < arr.length; i++) {
-			for (int j = 0; j < arr.length - i; j++) {
+		for (int i = 0; i < arr.length - 1; i++) {
+			for (int j = 0; j < arr.length - 1 - i; j++) {
 				if (arr[j + 1].compareTo(arr[j]) < 0) {
 					T temp = arr[j + 1];
 					arr[j + 1] = arr[j];
@@ -66,8 +89,120 @@ public static <T extends Comparable> void bubbleSort(T[] arr) {
 		}
 	}
 
-	public static <T extends Comparable> void bubbleSortImproved(T[] arr) {
+	/*
+	 * 改进的冒泡算法
+	 * 
+	 * 记录最大的位置
+	 */
+	public static <T extends Comparable> void bubbleSortImprovedV1(T[] arr) {
 
+		for (int i = 0; i < arr.length - 1; i++) {
+			int indexOfMax = arr.length - 1 - i;
+			for (int j = 0; j < arr.length - 1 - i; j++) {
+				if (arr[j].compareTo(arr[indexOfMax]) > 0)
+					indexOfMax = j;
+			}
+			T temp = arr[indexOfMax];
+			arr[indexOfMax] = arr[arr.length - 1 - i];
+			arr[arr.length - 1 - i] = temp;
+		}
 	}
 
+	/*
+	 * 用一个标志，如果某一趟没发生交换，说明已经有序
+	 * 
+	 * 并且最后面的元素是有序的，不需要参与后面的循环
+	 */
+	public static <T extends Comparable> void bubbleSortImprovedV2(T[] arr) {
+
+		int n = arr.length;
+		boolean swapped = false;
+
+		do {
+			swapped = false;
+			for (int i = 1; i < n; i++)
+				if (arr[i - 1].compareTo(arr[i]) > 0) {
+					T temp = arr[i - 1];
+					arr[i - 1] = arr[i];
+					arr[i] = temp;
+					swapped = true;
+				}
+
+			// 优化, 每一趟Bubble Sort都将最大的元素放在了最后的位置
+			// 所以下一次排序, 最后的元素可以不再考虑
+			n--;
+		} while (swapped);
+	}
+
+	/*
+	 * 第三次改进
+	 */
+	public static <T extends Comparable> void bubbleSortImprovedV3(T[] arr) {
+
+		int n = arr.length;
+		int newn; // 使用newn进行优化
+
+		do {
+			newn = 0;
+			for (int i = 1; i < n; i++)
+				if (arr[i - 1].compareTo(arr[i]) > 0) {
+					T temp = arr[i - 1];
+					arr[i - 1] = arr[i];
+					arr[i] = temp;
+					// 记录最后一次的交换位置,在此之后的元素在下一轮扫描中均不考虑
+					newn = i;
+				}
+			n = newn;
+		} while (newn > 0);
+	}
+
+	public static <T extends Comparable> void mergeSort(T[] arr) {
+		subMergeSort(arr, 0, arr.length - 1);
+	}
+
+	// 递归使用归并排序,对arr[l...r]的范围进行排序
+	private static <T extends Comparable> void subMergeSort(T[] arr, int l, int r) {
+		// 已经排完
+		if (l >= r)
+			return;
+
+		// 防止两个整形相加越界
+		long sum = r + l;
+		int middle = (int) (sum / 2);
+
+		subMergeSort(arr, l, middle);
+		subMergeSort(arr, middle + 1, r);
+		merge(arr, l, middle, r);
+	}
+
+	// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
+	private static <T extends Comparable> void merge(T[] arr, int l, int mid, int r) {
+
+		T[] aux = Arrays.copyOfRange(arr, l, r + 1);
+
+		int i = l;// 指向前半部分的起始位置`
+		int j = mid + 1;// 指向后半部分的起始位置
+		int k = l;// 指向原数组的插入位置
+
+		for (; k <= r; k++) {
+			if (i > mid) {
+				// 左边已经排完
+				arr[k] = aux[j - l];
+				j++;
+			} else if (j > r) {
+				// 右边已经排完了
+				arr[k] = aux[i - l];
+				i++;
+			} else if (aux[i - l].compareTo(aux[j - l]) < 0) {
+				arr[k] = aux[i - l];
+				i++;
+			} else {
+				arr[k] = aux[j - l];
+				j++;
+			}
+		}
+
+
+
+	}
 }

src/algorithm/SortTestHelper.java

@@ -1,5 +1,7 @@
 package algorithm;
 
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
 import java.util.Random;
 
 public class SortTestHelper {
@@ -16,6 +18,24 @@ public static Integer[] generateRandomArray(int n, int rangeR, int rangeL) {
 		return arr;
 	}
 
+	public static Integer[] generateNearlyOrderedArray(int n, int swapTimes) {
+		Integer[] arr = new Integer[n];
+		// 有序集合
+		for (int i = 0; i < n; i++) {
+			arr[i] = i;
+		}
+		// 进行交换
+		for (int j = 0; j < swapTimes; j++) {
+			int a = (int) (Math.random() * n);
+			int b = (int) (Math.random() * n);
+			int t = arr[a];
+			arr[a] = arr[b];
+			arr[b] = t;
+		}
+
+		return arr;
+	}
+
 	/*
 	 * 输出数组
 	 */
@@ -39,6 +59,29 @@ public static <T extends Comparable> boolean isSorted(T[] arr) {
 		return true;
 	}
 
-
-
+	/*
+	 * 测试排序算法的效率
+	 * 
+	 */
+	public static <T extends Comparable> void testSort(String sortName, String className, T[] arr) {
+		try {
+
+			Class sortClass = Class.forName(className);
+			Method sort = sortClass.getMethod(sortName, Comparable[].class);
+
+			long start = System.currentTimeMillis();
+			// 需要强转，因为接收的参数是可变参数，如果传入的是数组，则展开之后会出现错误，
+			// 所以需要进行强制转换为一个参数，反正接收的参数也是 Object
+			sort.invoke(null, (Object) arr);
+			long end = System.currentTimeMillis();
+			if (isSorted(arr))
+				System.out.println("\n" + sortName + " cost : " + (end - start));
+			else
+				System.out.println("\n" + sortName + " cost : 9999999999");
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
 }