幾種基本算法

在這裏記錄下：

/**
 * 排序
 */
public class PaiXuTest {

	// 一、直接插入排序
	/*
	 * 基本思想：在要排序的一組數中，假設前面(n-1)[n>=2] 個數已是排 好順序的，如今要把第n個數插到前面的有序數中，使得這 n個數
	 * 也是排好順序的。如此反覆循環，直到所有排好順序。
	 */
	public static void insertSort(int array[]) {
		int temp = 0;
		for (int i = 0; i < array.length; i++) {
			int j = i - 1;
			temp = array[i];
			for (; j >= 0 && temp < array[j]; j--) {
				array[j + 1] = array[j];// 將temp的值總體向後移動一個單位
			}
			array[j + 1] = temp;
		}

		for (int i = 0; i < array.length; i++) {
			System.out.println("插入排序="+array[i]);
		}
	}

	// 二、希爾排序（最小增量排序）
	/*
	 * 基本思想：算法先將要排序的一組數按某個增量 d（n/2,n爲要排序數的個數）分紅若 幹組，每組中記錄的下標相差
	 * d.對每組中所有元素進行直接插入排序，而後再用一個較小 的增量（d/2）對它進行分組，在每組中再進行直接插入排序。當增量減到 1 時，進行直接
	 * 插入排序後，排序完成。
	 */

	public static void shellSort(int array[]) {
		double d1 = array.length;
		int temp = 0;
		while (true) {
			d1 = Math.ceil(d1 / 2);
			int d = (int) d1;
			for (int i = 0; i < d; i++) {
				for (int j = i + d; j < array.length; j += d) {
					int k = j - d;
					temp = array[j];
					for (; k >= 0 && temp < array[k]; k -= d) {
						array[k + d] = array[k];
					}
					array[k + d] = temp;
				}
			}
			if (d == 1) {
				break;
			}

		}
		for (int i = 0; i < array.length; i++) {
			System.out.println("希爾排序="+array[i]);
		}
	}

	// 三、選擇排序
	/*
	 * 基本思想：在要排序的一組數中，選出最小的一個數與第一個位置的數交換；
	 * 
	 * 而後在剩下的數當中再找最小的與第二個位置的數交換，如此循環到倒數第二個數和最後一
	 * 
	 * 個數比較爲止。
	 */
	public static void selectSort(int array[]) {
		int point = 0;
		for (int i = 0; i < array.length; i++) {
			int j = i + 1;
			point = i;
			int temp = array[i];
			for (; j < array.length; j++) {
				if (array[j] < temp) {
					temp = array[j];
					point = j;
				}
			}
			array[point] = array[i];
			array[i] = temp;
		}

		for (int i = 0; i < array.length; i++) {
			System.out.println("選擇排序"+array[i]);
		}
	}

	// 四、冒泡排序
	/*
	 * 基本思想：在要排序的一組數中，對當前還未排好序的範圍內的所有數，自上而下對
	 * 
	 * 相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的
	 * 
	 * 數比較後發現它們的排序與排序要求相反時，就將它們互換。
	 */
	public static void bubbleSort(int array[]){
		int temp = 0;
		for (int i = 0; i < array.length-1; i++) {
			for (int j = 0; j < array.length-1-i; j++) {
				if (array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		for (int i = 0; i < array.length; i++) {
			System.out.println("冒泡排序"+array[i]);
		}
	}
	
	//五、快速排序 
	/*
	 * 基本思想：選擇一個基準元素,一般選擇第一個元素或者最後一個元素,經過一趟掃描，
	 * 
	 * 將待排序列分紅兩部分,一部分比基準元素小,一部分大於等於基準元素,此時基準元素在其
	 * 
	 * 排好序後的正確位置,而後再用一樣的方法遞歸地排序劃分的兩部分。
	 */ 
	public static void quickSort(int array[]){
		// 判斷數組是否爲空
		if (array.length > 0) {
			_quickSort(array, 0, array.length-1);
		}
		for (int i = 0; i < array.length; i++) {
			System.out.println("快速排序="+array[i]);
		}
	}
	public static	int getMiddle(int[] list,int low,int hight){
		// 數組的第一個作爲中軸
		int temp = list[low];
		while (low < hight) {
			while (low < hight && list[hight] >= temp) {
				hight --;	
			}
			// 比中軸小的記錄移動到低	端
			list[low] = list[hight];
			while (low < hight && list[low] <= temp) {
				low ++;
			}
			// 比中軸大的移動到高端
			list[hight] = list[low];
		}
		// 中軸記錄到尾
		list[low] = temp;
		// 返回中軸的位置
		return low;
	}
	public static void _quickSort(int[] list,int low,int hight) {
		if (low < hight) {
			// 將list 數組進行一分爲二
			int middle = getMiddle(list, low, hight);
			// 對低字表進行遞歸排序
			_quickSort(list, low, middle-1);
			// 對高子表進行遞歸排序
			_quickSort(list, middle+1, hight);
		}
	}
	
	// 六、歸併排序
	/*
	 * 基本排序：歸併（Merge）排序法是將兩個（或兩個以上）有序表合併成一個新的有
	 * 
	 * 序表，即把待排序序列分爲若干個子序列，每一個子序列是有序的。而後再把有序子序列合併
	 * 
	 * 爲總體有序序列。
	 */ 
	public static void mergingSort(int array[]){
		sort(array,0,array.length-1);
		for (int i = 0; i < array.length; i++) {
			System.out.println("歸併排序"+array[i]);
		}
	}
	public static void sort(int[] array, int left, int right) {
		if (left < right) {
			// 找出中間索引
			int middle = (left+right) / 2;
			// 對左邊數組進行遞歸
			sort(array, left, middle);
			// 對右邊數組進行遞歸
			sort(array, middle+1, right);
			// 合併
			merge(array,left,middle,right);
		}
		
	}
	public static void merge(int[] array, int left, int middle, int right) {
		int[] tempArray = new int[array.length];
		int mid = middle +1;
		// third 記錄中間數組的索引
		int third = left;
		int temp = left;
		while (left <= middle && mid <= right) {
			// 從兩個數組中取出最小的數組放在中間數組
			if (array[left] <= array[mid]) {
				tempArray[third++] = array[left++];
			}else{
				tempArray[third++] = array[mid++];
			}
		}
		// 剩餘部分依次放入中間數組
		while (mid <= right) {
			tempArray[third++] = array[mid++];
		}
		while (left <= middle) {
			tempArray[third++] = array[left++];
		}
		// 將中間數組中的內容複製到原數組
		while (temp <= right) {
			array[temp] = tempArray[temp++];
		}
	}

	// 主程序
	public static void main(String[] args) {
		int array[] = { 49, 38, 65, 97, 76, 13, 27 };
		/* Java 工具類
		 * Arrays.sort(array);
		for (int i = 0; i < array.length; i++) {
			System.out.println("--" + array[i]);
		}*/

		// 一、PaiXuTest.insertSort(array);
		// 二、PaiXuTest.shellSort(array);
		// 三、PaiXuTest.selectSort(array);
		// 四、bubbleSort(array);
		// 五、quickSort(array);
		// 六、mergingSort(array);
	}

}