一、数组排序算法
1.1 冒泡排序
在程序设计中，经常需要将一组数列进行排序，这样更加方便统计与查询。
冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将小数往前放、大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。
（ 1 ）基本思想
冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动数组前面，把大的元素移动数组后面（也就是两个元素交换位置），这样较小的元素就想气泡一样从底部上升到顶部。
（ 2 ）算法示例
冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般为要排序的数组长度减 1 次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序。而内层循环主要用于对比数组中每个临近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。
（ 3 ）算法实现
eg ：实现冒泡排序，正排序。
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 = 0 ; i < array.length ; i++){
//比较相邻两个元素，较大的数往后冒泡
for(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 : arrray){ //遍历数组
System.out.print(">"+i); //输出每个数组元素值
}
System.out.println();
}
}
运行结果为 ：> 1 > 3 > 4 > 15 > 24 > 63
冒泡排序的主要思想是：把相邻两个元素进行比较，如满足一定条件则进行交换（如判断大小或日期前后等），每次循环都将最大（或最小）的元素排在最后，下一次循环是对数组中其他的元素进行类似操作。
1.2 直接选择排序
直接选择排序方法是属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法。
（ 1 ）基本思想
直接选择排序的基本思想是将排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。
与冒泡排序相比，直接选择排序的交换次数要少很多，所以速度更快些。
（ 2 ）算法示例
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序地放在已排好序的数列的最后，直到全部待排序的数据元素排完。
初识数组资源 [ 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
（ 3 ）算法实现
实现直接选择排序，正排序。
/**
* 直接选择排序算法实例
*/
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){ //遍历数组
System.out.print(">"+i); //输出每个数组元素值
}
System.out.println();
}
} 运行结果为 ： > 1 > 3 > 4 > 15 > 24 > 63
1.3 反转排序
反转排序就是以相反的顺序把原有数组的内容重新排序。反转排序算法在程序开发中也经常用到。
（ 1 ）基本思想
就是把数组最后一个元素与第一个元素替换，倒数第二个与第二个元素替换，以此类推，直到所有数组元素反转替换。
（ 2 ）算法示例
反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半数次，如数组长度为 7 ，那么 for 循环只需要循环 3 次 。
eg ：
初始数组资源 [ 10 20 30 40 50 60 ] 第一趟排序后 60 [ 20 30 40 50 ] 10 第二趟排序后 60 50 [ 30 40 ] 20 10 第三趟排序后 60 50 40 30 20 10
（ 3 ）算法实现
实现反转排序。
/**
* 反转排序算法实例
*/
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];
arrray[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){ //遍历数组
System.out.printl("\t"+i); //输出每个数组元素值
}
System.out.println();
}
}
运行结果为 ：
数组原有内容 ： 10 20 30 40 50 60
数组反转后的内容 ： 60 50 40 30 20 10