几种基本算法

在这里记录下：

/**
 * 排序
 */
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);
	}

}