数组排序

冒泡排序

基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，即交换两个元素的位置。
冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序。内层循环用于对比数组中每个相邻元素的大小，已确定是否要交换位置，对比和交换次数随排序轮数而减少。

public class BubbleSort {
	public static void main(String[] args) {
		// 创建一个数组，这个数组元素是乱序的
		int[] array = { 63, 4, 24, 1, 3, 15 };
		// 创建冒泡排序类的对象
		BubbleSort sorter = new BubbleSort();
		// 调用排序方法将数组排序
		sorter.sort(array);
	}
	
	/**
	 *冒泡排序
	 * 
	 * @param array
	 *            要排序的数组
	 */
	public void sort(int[] array) {
		for (int i = 1; i < array.length; i++) {
			// 比较相邻两个元素，较大的数往后冒泡
			for (int j = 0; j < array.length - i; j++) {
				if (array[j] > array[j + 1]) {
					int temp = array[j];// 把第一个元素值保持到临时变量中
					array[j] = array[j + 1];// 把第二个元素值保存到第一个元素单元中
					array[j + 1] = temp;// 把临时变量也就是第一个元素原值保持到第二个元素中
				}
			}
		}
		showArray(array);// 输出冒泡排序后的数组元素
	}
	
	/**
	 * 显示数组所有元素
	 * 
	 * @param array
	 *            要显示的数组
	 */
	public void showArray(int[] array) {
		for (int i : array) {// foreach格式遍历数组
			System.out.print(" >" + i);// 输出每个数组元素值
		}
		System.out.println();
	}
}

运行结果如图

直接选择排序

基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值。
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序地放在已排好序的数列的最后，直到全部待排序的数据元素排完。
例如：
初始数组资源【63 4 24 1 3 15】
第一趟排序后【15 4 24 1 3】63
第二趟排序后【15 4 3 1】24 63
第三趟排序后【1 4 3】15 24 63
第四趟排序后【1 3】4 15 24 63
第五趟排序后【1】3 4 15 24 63

/**
 * 直接选择排序算法实例
 * 
 * @author Li Zhong Wei
 */
public class SelectSort {
	public static void main(String[] args) {
		// 创建一个数组，这个数组元素是乱序的
		int[] array = { 63, 4, 24, 1, 3, 15 };
		// 创建直接排序类的对象
		SelectSort sorter = new SelectSort();
		// 调用排序对象的方法将数组排序
		sorter.sort(array);
	}
	
	/**
	 *直接选择排序法
	 * 
	 * @param array
	 *            要排序的数组
	 */
	public void sort(int[] array) {
		int index;
		for (int i = 1; i < array.length; i++) {
			index = 0;
			for (int j = 1; j <= array.length - i; j++) {
				if (array[j] > array[index]) {
					index = j;
				}
			}
			// 交换在位置array.length-i和index(最大值)两个数
			int temp = array[array.length - i];// 把第一个元素值保持到临时变量中
			array[array.length - i] = array[index];// 把第二个元素值保存到第一个元素单元中
			array[index] = temp;// 把临时变量也就是第一个元素原值保持到第二个元素中
		}
		showArray(array);// 输出直接选择排序后的数组值
	}
	
	/**
	 * 显示数组所有元素
	 * 
	 * @param array
	 *            要显示的数组
	 */
	public void showArray(int[] array) {
		for (int i : array) {// foreach格式遍历数组
			System.out.print(" >" + i);// 输出每个数组元素值
		}
		System.out.println();
	}
}

反转排序

就是以相反的顺序把原有的数组的内容重新排序。
基本思想就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所以数组元素反转替换。
只需要循环数组长度的半数次。
例如：
初始数组资源【10 20 30 40 50 60】
第一趟排序后 60【20 30 40 50 】10
第二趟排序后 60 50【30 40】20 10
第三趟排序后 60 50 40 30 20 10

/**
 * 反转排序算法实例
 * 
 * @author Li Zhong Wei
 */
public class ReverseSort {
	public static void main(String[] args) {
		// 创建一个数组
		int[] array = { 10, 20, 30, 40, 50, 60 };
		// 创建反转排序类的对象
		ReverseSort sorter = new ReverseSort();
		// 调用排序对象的方法将数组反转
		sorter.sort(array);
	}
	
	/**
	 *直接选择排序法
	 * 
	 * @param array
	 *            要排序的数组
	 */
	public void sort(int[] array) {
		System.out.println("数组原有内容：");
		showArray(array);// 输出排序前的数组值
		int temp;
		int len = array.length;
		for (int i = 0; i < len / 2; i++) {
			temp = array[i];
			array[i] = array[len - 1 - i];
			array[len - 1 - i] = temp;
		}
		System.out.println("数组反转后内容：");
		showArray(array);// 输出排序后的数组值
	}
	
	/**
	 * 显示数组所有元素
	 * 
	 * @param array
	 *            要显示的数组
	 */
	public void showArray(int[] array) {
		for (int i : array) {// foreach格式遍历数组
			System.out.print("\t" + i);// 输出每个数组元素值
		}
		System.out.println();
	}
}

运行结果如下：