Java算法分析2—————几种排序&汉诺塔算法

一：插入排序

/*
 * 插入排序
 */
/*
 * 原序列 [12] 15 9 20 6 31 24
 * 第0趟 [12 15] 9 20 6 31 24
 * 第1趟 [9 12 15] 20 6 31 24
 * 第2趟 [9 12 15 20] 6 31 24
 * 第3趟 [6 9 12 15 20] 31 24
 * n个数，一共需要多少趟？n个数，n-1趟
 * 第0趟，把1位置的数，和1位置之前的数进行比较，按大小顺序排列
 * 第1趟，把2位置的数，和2位置之前的数进行比较，按大小顺序排列 ...
 * 第i趟，把i+1位置的数，和i位置之前的数进行比较，按大小顺序排列。
 */
public class sort01 {
	public static void main(String[] args) {
		int[] num = { 3, 4, 1, 6, 3 };
		for (int i = 0; i < num.length - 1; i++) {
			for (int j = 0; j < i + 1; j++) { // 第i趟...将i+1位置的数与i+1位置之前的数进行比较
				// 判断当前数num[j]与num[i+1]进行比较
				if (num[i + 1] < num[j]) {
					int temp = num[i + 1];
					num[i + 1] = num[j];
					num[j] = temp;
				}
			}
		}
		for (int i = 0; i <= num.length - 1; i++) {
			System.out.println("排序完成后:" + num[i]);
		}
	}
}

二：选择排序

/*
 * 选择排序
 */
/*
 * 以下为简单选择排序的存储状态，其中大括号内为无序区，大括号外为有序序列：
 * 初始序列：{ 49 27 65 97 76 12 38 }
 * 第1趟：12与49交换：12 { 27 65 97 76 49 38 }
 * 第2趟：27不动　：12 27 { 65 97 76 49 38 }
 * 第3趟：65与38交换：12 27 38 { 97 76 49 65 }
 * 第4趟：97与49交换：12 27 38 49 { 76 97 65 }
 * 第5趟：76与65交换：12 27 38 49 65 { 97 76 }
 * 第6趟：97与76交换：12 27 38 49 65 76 97
 */
public class sort03 {
	public static void main(String[] args) {
		int[] num = { 2, 5, 3, 23, 6, 9, 66 };
		for (int i = 0; i <= num.length - 1; i++) { // 比较N轮
			// 找最小
			int min = num[i]; // 每轮使第一个数最小，依次用后面的比
			for (int j = i + 1; j <= num.length - 1; j++) {
				if (min > num[j]) {
					min = num[j];
				}
			}
			// 判断下最小的数出现在什么位置
			int j;
			for (j = i; j <= num.length - 1; j++) {
				if (num[j] == min) {
					break;
				}
			}
			// j位置为最小值
			// 交换位置
			if (j > i) {
				int temp = num[j];
				num[j] = num[i];
				num[i] = temp;
			}

		}
		// 打印
		for (int i = 0; i <= num.length - 1; i++) {
			System.out.println(num[i]);
		}

	}
}

三：冒泡排序

/*
 * 冒泡排序
 */
public class sort04 {
	static void sort() {
		int[] num = { 2, 1, 3, 5, 4, 7, 2 };
		for (int i = 0; i < num.length - 1; i++) { // 比较n-1轮
			for (int j = 0; j < num.length - i - 1; j++) {
				if (num[j] > num[j + 1]) {
					int temp = num[j];
					num[j] = num[j + 1];
					num[j + 1] = temp;
				}
			}
		}
		// 打印
		for (int i = 0; i <= num.length - 1; i++) {
			System.out.println(num[i]);
		}
	}

	public static void main(String[] args) {
		sort();
	}
}

四：汉诺塔算法

/*
 * 汉诺塔 汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。
 * 大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。
 * 大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。
 * 并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘
 *  A柱 B柱 C柱
 *  64个盘子，由小到大叠放在A柱上， 现在，要求把这64个盘子，从A柱移动到C柱
 *  要求：移动过程中，大盘子不能覆盖小盘子，可以借助B柱。
 *  1个盘子：从A端到C
 *  2个盘子，把上的小盘子挪到B柱临时存放，下面的大盘子移动到C柱，再将B柱上临时存放的小盘子，移动到C柱。
 *  3个盘子： 更多盘子怎么办？
 *  n个盘子
 *  a.先把上面的n-1个盘子 从A，借助C，移动到B
 *  b.把下面一个盘子，从A移动到C
 *  c.把B柱上的n-1个盘子从B借助A，移动到C 2的64次方-1 次
 */
public class sort02 {
	static void hanoi(int n, String src, String mid, String dest) {
		if (n == 1) {
			System.out.println(src + "-->" + dest);
		} else {
			hanoi(n - 1, src, dest, mid);
			hanoi(1, src, null, dest);
			hanoi(n - 1, mid, src, dest);
		}
	}

	public static void main(String[] args) {
		hanoi(3, "A", "B", "C");
	}

}