数组排序及相关各种算法

对数组中的元素进行排序，常见算法如下：

一、选择排序算法

       选择排序的基本思想是，每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

public static void selectSort(int[] array) {
	int index;
	/*
	 * 需要选择排序的次数，每次排序好一个元素，即需要排序的元素个数-1，故可从1开始排序
	 */
	for (int i = 1; i < array.length; i++) {
		// 每次排序前，将第一个数设为起始值
		index = 0;
		/*
		 * 查找未排序的序列中的最大值， 第一个比较下标为1的元素， 最后一个比较下标为length-i的元素
		 */
		for (int j = 1; j <= array.length - i; j++) {
			if (array[j] > array[index]) 
				index = j;
		}
		/*
		 * 将最大值与未排序的最后一个元素交换
		 */
		int temp = array[array.length - i];
		array[array.length - i] = array[index];
		array[index] = temp;
	}
}

注：如果数组有重复值，应使用选择排序。

       选择排序法从数组中挑选最大值并放在数组最后，而遇到重复的相等值不会做任何处理，所以程序允许数组有重复值的情况，建议使用选择排序法，因为它的数据交换次数最少，相对速度也会略微提升，这取决于数组中重复值的数量。

二、冒泡排序算法

       冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

       冒泡算法在双层循环中实现，其中外层循环控制排序轮数，要排序数组长度-1次。而内层循环主要是用于对比临近元素的大小，以确定是否交换元素，对比和交换次数依排序轮数而减少。

public static void BubbleSort(int[] array) {
	/*
	 * 控制循环的次数,每次循环将最大的一个值排序到最后，即数组长度-1
	 */
	for (int i = 1; i < array.length; i++) {
		/*
		 * 一次冒泡过程中，比较并交换相邻元素，从而将0到length-i范围内的最大值传递到最后
		 */
		for (int j = 1; j <= array.length - i; j++) {
			if (array[j - 1] > array[j]) {
				int temp = array[j - 1];
				array[j - 1] = array[j];
				array[j] = temp;
			}
		}
	}
}

三、快速排序算法

       快速排序算法是对冒泡排序算法的一种改进，其排序速度相对较快，它的基本思想是，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后在按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此使整个数据变成有序序列。

public static void QuickSort(int[] array, int lowIndex, int highIndex) {
	int lo = lowIndex;
	int hi = highIndex;
	int mid;
	if (highIndex > lowIndex) {
		mid = array[(lowIndex + highIndex) / 2];
		while (lo <= hi) {
			while ((lo < highIndex) && (array[lo] < mid))
				++lo;
			while ((hi > lowIndex) && (array[hi] > mid))
				--hi;
			if (lo <= hi) {
				int temp = array[lo];
				array[lo] = array[hi];
				array[hi] = temp;
				++lo;
				--hi;
			}
		}
		if (lowIndex < hi)
			QuickSort(array, lowIndex, hi);
		if (lo < highIndex)
			QuickSort(array, lo, highIndex);
	}
}

四、直接插入算法

       插入算法是将一个记录插入到有序数列中，使得到的新的数列仍然有序。插入排序算法的思想是，将n个有序数存放在数组a中，要插入的数为x，首先确定x插在数组中的位置p，数组中p之后的元素都向后移一个位置，空出a(p)，将x放入a(p)。这样即可实现插入后数列仍然有序。

public static void InsertSort(int[] array) {
	int temp;          //定义临时变量
	int j;
	/*
	 * 需要插入元素的个数，即数组长度-1
	 */
	for (int i = 1; i < array.length; i++) {
		temp = array[i];              //保存临时变量,即将要插入的数组元素
		for (j = i - 1; j >= 0 && array[j] > temp; j--) {
			array[j + 1] = array[j];     //将比插入元素大的元素向后移
		}
		array[j + 1] = temp;
	}
}

五、使用sort方法对数组进行排序

       Arrays类位于java.util包中，它是数组的一个工具类，包含许多方法，其中sort()方法就是Arrays类提供的对数组进行排序的方法，它有很多重载格式，可以接收任何数据类型的数组并执行不同类型的排序。

注：Arrays类提供了创建、操作、搜索和排序数组的方法。在程序开发中有效利用Arrays类的各种方法来完成数组操作将大幅度提升程序的开发效率，并且Arrays类的方法时经测试的，可以避免程序开发中错误代码的出现。

总结：

1>排序算法的空间复杂度是指排序算法运行所需要的额外消耗存储空间，一般使用O()来表示，如直接插入排序法的空间复杂度为O(1)。

2>各种排序比较，如下图：