嗯，在经典的排序算法里面，有：冒泡排序，选择排序，插入排序，希尔排序，二叉归并排序，快速排序，堆排序
下面给出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[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
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[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
=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
= 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