Java排序算法之冒泡排序

冒泡排序算法的基本思想是：首先将第n-1个记录的关键字和第n个记录的关键字进行比较，若为“逆序”（即L.r[n].key<L.r[n-1].key），则将两个记录交换之，然后比较第n-2个记录和第n-1个记录的关键字。依次类推，直至第1个记录的关键字和第2个记录的关键字比较过为止。这是第一趟起泡排序，其结果是使得关键字最小的记录被安置到第一个记录的位置上；然后进行第二趟起泡排序，对后面的n-1个记录进行同样的操作，其结果是使关键字次小的记录被安置到第2个记录的位置；一般地，第i趟起泡排序是从L.r[n] 到L.r[i]依次比较相邻两个记录的关键字，并在“逆序”时交换相邻记录，其结果是这n-i+1个记录中关键字最小的记录被交换到第i的位置上。整个排序过程需要进行K(1≤k<n)趟起泡排序，显然，判别起泡排序结束的条件应该是“在一趟排序过程中没有进行过交换记录的操作”。

    以下是冒泡排序的JAVA代码实现：

package com.fit.bubble.sort;

public class BubbleSort {

	/**
	 * 首先将第n-1个记录的关键字和第n个记录的关键字进行比较，若为“逆序”（即L.r[n].key<L.r[n-1].key），则将两个记录交换之，
	 * 然后比较第n-2个记录和第n-1个记录的关键字。依次类推，直至第1个记录的关键字和第2个记录的关键字比较过为止。这是第一趟起泡排序，
	 * 其结果是使得关键字最小的记录被安置到第一个记录的位置上
	 * ；然后进行第二趟起泡排序，对后面的n-1个记录进行同样的操作，其结果是使关键字次小的记录被安置到第2个记录的位置
	 * ；一般地，第i趟起泡排序是从L.r[n]
	 * 到L.r[i]依次比较相邻两个记录的关键字，并在“逆序”时交换相邻记录，其结果是这n-i+1个记录中关键字最小的记录被交换到第i的位置上
	 * 。整个排序过程需要进行K(1≤k<n)趟起泡排序，显然，判别起泡排序结束的条件应该是“在一趟排序过程中没有进行过交换记录的操作”
	 * 
	 * @param array
	 */
	public static void sort(int[] array) {

		int length = array.length;
		int temp = 0;

		for (int i = 0; i < length; i++) {
			for (int j = i; j < length - 1; j++) {
				//print(array);
				if (array[j] > array[j + 1]) {
					temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
				}
			}
			//System.out.println("-----------------------");
			print(array);
		}

	}

	public static void print(int[] array) {
		StringBuffer sb = new StringBuffer("[");
		for (int i = 0; i < array.length; i++) {
			if (i < array.length - 1) {
				sb.append(array[i]).append(",");
			} else {
				sb.append(array[i]);
			}
		}

		sb.append("]");

		System.out.println(sb);
	}

	public static void main(String[] args) {
		int[] array = new int[] { 54, 3, 11, 34, 12, 8, 19 };

		print(array);

		System.out.println("=====================");

		sort(array);

		print(array);
	}
}

运行结果如下：

[54,3,11,34,12,8,19]
=====================
[3,11,34,12,8,19,54]
[3,11,12,8,19,34,54]
[3,11,8,12,19,34,54]
[3,11,8,12,19,34,54]
[3,11,8,12,19,34,54]
[3,11,8,12,19,34,54]
[3,11,8,12,19,34,54]
[3,11,8,12,19,34,54]