嗯，在经典的排序算法里面，有：冒泡排序，选择排序，插入排序，希尔排序，二叉归并排序，快速排序，堆排序
下面给出java的实现方式，不过快速排序没有搞定，研究中
package net.itaem.sort;
/**
* 数组排序
* */
public class ArraySorted {
/**
* 冒泡排序(而且是简单的冒泡排序，应该属于交换排序，不属于经典的冒泡排序)
* */
public static void bubble(int[] source){
if(source.length == 0 || source.length == 1) return; //无空，或者是1的情况下，不需要排序
for(int i=0; i<source.length; i++){
for(int j=i+1; j<source.length; j++){ //简单的比较，然后交换数据...
if(source[i] > source[j]){
//交换
int temp = source[i];
source[i] = source[j];
source[j] = temp;
}
}
}
}
/**
* 经典的冒泡排序
* */
public static void classicBubble(int[] source){
if(source.length == 0 || source.length == 1) return; //无空，或者是1的情况下，不需要排序
boolean flag = true;
for(int i=0; i<source.length && flag; i++){
flag = false; //记录下下面一个循环是否有交换数据
for(int j=source.length-1; j>i; j--){ //从后面开始，这样子可以将小的元素在每次循环中都提前
if(source[i] > source[j]){
//交换
int temp = source[i];
source[i] = source[j];
source[j] = temp;
flag = true;
}
}
}
}
/**
* 选择排序
* 这也是一种普通的交换排序
* */
public static void swap(int[] source){
if(source.length == 0 || source.length == 1) return; //无空，或者是1的情况下，不需要排序
for(int i=0; i<source.length; i++){
int min = i; //默认情况下，第i个元素为最小的元素
for(int j=i+1; j<source.length; j++){ //找到最小的小标
if(source[min] > source[j]){
min = j; //记录下
}
}
if(min != i){ //如果最小元素存在，交换
int temp = source[i];
source[i] = source[min];
source[min] = temp;
}
}
}
/**
* 插入排序
*
* */
public static void insert(int[] source){
if(source.length == 0 || source.length == 1) return; //无空，或者是1的情况下，不需要排序
int i=1, j = 0;
for(; i<source.length; i++){
if(source[i] < source[i-1]){
int temp = source[i]; //记住要插入的变量
for(j=i-1;j>=0 && source[j] > temp; j--){ //移动所有比temp大的元素，也就是要插入这个大的元素
source[j+1] = source[j];
}
//插入元素
source[++j] = temp;
}
}
}
/**
* 堆排序
* */
public static void heap(int[] source){
if(source.length == 0 || source.length == 1) return; //无空，或者是1的情况下，不需要排序
int i = 0;
//构建一个大顶堆
for(i = source.length/2; i>=0; i--){
heapAjust(source, i, source.length);
}
//开始排序
for(i=source.length-1; i>=0; i--){
swapItem(source, 0, i); //每次将最大的元素和最小的元素进行交换
heapAjust(source, 0, i-1); //重新形成一个大顶堆
}
}
//交换数据
private static void swapItem(int[] source, int i, int j) {
int temp = source[i];
source[i] = source[j];
source[j] = temp;
}
/**
* 形成一颗大顶堆树
* */
private static void heapAjust(int[] source, int s, int length) {
int temp = 0, j = 0;
temp = source[s];
for(j = 2*s; j<length; j*=2){
if(j < length-1 && source[j] < source[j+1]){
++j;
}
if(temp >= source[j]){
break;
}
source[s] = source[j];
s = j;
}
source[s] = temp;
}
/**
* 二叉归并排序
* */
public static void mergeSort(int[] source){
if(source.length == 0 || source.length == 1) return; //无空，或者是1的情况下，不需要排序
//归并排序
merge0(source, 0, source.length-1);
}
private static void merge0(int[] source, int start, int end) {
if(start != end){
int middle = (start+end)/2;
merge0(source, start, middle);
merge0(source, middle+1, end);
merge(source, start, middle, middle+1, end);
}
}
private static void merge(int[] array, int start1, int end1, int start2,
int end2) {
int i=start1;//左路起始索引
int j=start2;//右路起始索引
int k=0;
//归并的时候，会将两个数组数据按照大小输入到一个临时数组中
//建立临时长度为两个子列表长度的数组
int[] temp=new int[end2-start1+1];
//循环遍历，按顺序找出两个表中的最小数据依次放入临时表中
//注意此时左路和右路已经是有序的了。
//当一路有一个小的，则会索引加1，继续喝另外一路的上次索引进行比较
while(i<=end1&&j<=end2)
{
//这里确定归并的次序大小
if(array[i]>array[j])
temp[k++]=array[j++];
else
temp[k++]=array[i++];
}
//把剩下的元素放入临时数组中，只有一路的
while(i<=end1)
temp[k++]=array[i++];
while(j<=end2)
temp[k++]=array[j++];
k=start1;
for(int item:temp)
array[k++]=item;
}
public static void main(String[] args) {
int[] waitedSort = new int[5];
waitedSort[0] = 4;
waitedSort[1] = 1;
waitedSort[2] = 2;
waitedSort[3] = 5;
waitedSort[4] = 3;
mergeSort(waitedSort);
//bubble(waitSorted);
//heap(waitedSort);
//insert(waitedSort);
//swap(waitSorted);
for(int i=0; i<waitedSort.length; i++){
System.out.println(waitedSort[i]);
}
}
}
原文地址：http://blog.csdn.net/u010469003/article/details/25742355
