日常操作中常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。
冒泡排序
/**
* <strong>冒泡排序法</strong>
*
* 使用类似于冒泡的方法，将数组中的较小的元素冒泡到最后，从而实现对于数据从大到小的排列顺序
*
* 使用第一个元素，逐个同后面的元素比较，如果第一个元素小，则上浮，同比较的元素替换位置，将最大的元素替换到第一位
* 然后继续从第二个元素开始，逐个同后面的元素比较，将第二大的元素排在第二位，直至排序到最后一位，就可以形成从大到小的排列顺序
*
* @param numbers 需要排序的数组
*/
public static void bubbleSort(int[] numbers) {
int temp, size = numbers.length;
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (numbers[i] < numbers[j]) {//如果前面的元素小，则上浮
temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
}
}
}
}
快速排序
/**
* <strong>快速排序法</strong>
*
* <ul>
* <li>从数列中挑出一个元素，称为“基准”</li>
* <li>重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，
* 该基准是它的最后位置。这个称为分割（partition）操作。</li>
* <li>递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。</li>
* </ul>
*
* @param numbers 需要排序的数组
* @param start 开始位置
* @param end 结束位置
*/
public static void quickSort(int[] numbers, int start, int end) {
if (start < end) {
int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）
int temp; // 记录临时中间值
int i = start, j = end;
do {
while ((numbers[i] < base) && (i < end))//在不超过结束位之前的数字小于基准数字的，不进行处理
i++;
while ((numbers[j] > base) && (j > start))//在不小于开始位之前的数字大于基准数字的，不进行处理
j--;
if (i <= j) {//一旦到达此处，则认为i位置的值大于等于基准值，j位置的值小于等于基准值，则替换i和j位置的值
temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
i++;
j--;
}
} while (i <= j);//在开始位置和结束位置之间
if (start < j)//如果开始位置小于小于j判断的位置，则比较这两个区段内的数字，进行位置对换
quickSort(numbers, start, j);
if (end > i)//如果结束位置大于i判断的位置，则比较这两个区段的位置，进行位置对换
quickSort(numbers, i, end);
}
}
选择排序
/**
* 选择排序
* <ul>
* <li>在未排序序列中找到最小元素，存放到排序序列的起始位置</li>
* <li>再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。</li>
* <li>以此类推，直到所有元素均排序完毕。</li>
* </ul>
*
* @param numbers 需要排序的数组
*/
public static void selectSort(int[] numbers) {
int temp, size = numbers.length;
for (int i = 0; i < size; i++) {//从第一个元素开始定位
int k = i;
for (int j = size - 1; j >i; j--) {//从最后一个元素开始寻找
if (numbers[j] < numbers[k]) k = j;//如果被寻找的元素，小于定位的元素，则替换二者的位置
}
temp = numbers[i];
numbers[i] = numbers[k];
numbers[k] = temp;
}
}
插入排序
/**
* 插入排序<br/>
* <ul>
* <li>从第一个元素开始，该元素可以认为已经被排序</li>
* <li>取出下一个元素，在已经排序的元素序列中从后向前扫描</li>
* <li>如果该元素（已排序）大于新元素，将该元素移到下一位置</li>
* <li>重复步骤3，直到找到已排序的元素小于或者等于新元素的位置</li>
* <li>将新元素插入到该位置中</li>
* <li>重复步骤2</li>
* </ul>
*
* @param numbers
*/
public static void insertSort(int[] numbers) {
int size = numbers.length, temp, j;
for(int i=1; i<size; i++) {
temp = numbers[i];
for(j = i; j > 0 && temp < numbers[j-1]; j--)
numbers[j] = numbers[j-1];
numbers[j] = temp;
}
}
归并排序
/**
* 归并排序<br/>
* <ul>
* <li>申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列</li>
* <li>设定两个指针，最初位置分别为两个已经排序序列的起始位置</li>
* <li>比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置</li>
* <li>重复步骤3直到某一指针达到序列尾</li>
* <li>将另一序列剩下的所有元素直接复制到合并序列尾</li>
* </ul>
*
* @param numbers
*/
public static void mergeSort(int[] numbers) {
sort(numbers, 0, numbers.length - 1);
}
public static void sort(int[] numbers, int left, int right) {
if (left >= right)
return;
// 找出中间索引
int center = (left + right) / 2;
// 对左边数组进行递归
sort(numbers, left, center);
// 对右边数组进行递归
sort(numbers, center + 1, right);
// 合并
merge(numbers, left, center, right);
System.out.println(Arrays.toString(numbers));
}
/**
* 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序
*
* @param numbers
* 数组对象
* @param left
* 左数组的第一个元素的索引
* @param center
* 左数组的最后一个元素的索引，center+1是右数组第一个元素的索引
* @param right
* 右数组最后一个元素的索引
*/
public static void merge(int[] numbers, int left, int center, int right) {
// 临时数组
int[] tmpArr = new int[numbers.length];
// 右数组第一个元素索引
int mid = center + 1;
// third 记录临时数组的索引
int third = left;
// 缓存左数组第一个元素的索引
int tmp = left;
while (left <= center && mid <= right) {
// 从两个数组中取出最小的放入临时数组
if (numbers[left] <= numbers[mid]) {
tmpArr[third++] = numbers[left++];
} else {
tmpArr[third++] = numbers[mid++];
}
}
// 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
while (mid <= right) {
tmpArr[third++] = numbers[mid++];
}
while (left <= center) {
tmpArr[third++] = numbers[left++];
}
// 将临时数组中的内容拷贝回原数组中
// （原left-right范围的内容被复制回原数组）
while (tmp <= right) {
numbers[tmp] = tmpArr[tmp++];
}
}
归并算法因为需要创建新的数组，然后在排序完成后进行合并，因此会占用更多的内存空间，且随着数组内元素增长，数组拷贝和合并也会占用更多的时间。
参考：
Java实现几种常见排序方法
