java实现 冒泡排序 插入排序 选择排序

package test.sort;

public class TestSort {

/**
* 冒泡排序(升序)
* 思想：将要排序的元素看做是竖着的排序的气泡，较小的元素比较轻，从而要往上符。在冒泡排序算法中我们要
* 对这个气泡序列处理若干遍，所谓一遍处理，就是自底向上检查一遍这个序列。并时刻注意两个相邻的元素的顺序
* 是否正确，如果发现两个相邻元素的顺序不对，即轻的元素子下面，就交互他们的位置，显然，处理一遍之后，最轻
* 的元素就浮到最高位置，处理二遍之后，次轻的元素就浮到次高位置，在做第二编处理时，由于最高位置的元素已是
* 最轻的元素，所以不必检查，一般地，第i编处理时，不必检查第i高位置以上的元素，应为前面i-1编的处理，他们
* 正确的排好序。
* @param src 待排序数组
*/
private static void toBubbleSortAsc(int[] src){
long start = System.currentTimeMillis();
for(int k=0;k<1000000;k++){
for(int i=0;i<src.length;i++){
for(int j=i+1;j<src.length;j++){
int temp;
if(src[i]>src[j]){
temp=src[j];
src[j]=src[i];
src[i]=temp;
}
}
}
}
System.out.println("冒泡排序(升序)如下,耗时:"+ (System.currentTimeMillis() - start));
}
/**
* 冒泡排序(降序)
* @param src 待排序数组
*/
private static void toBubbleSortDesc(int[] src){

long start = System.currentTimeMillis();
for(int k=0;k<1000000;k++){
for(int i=0;i<src.length;i++){
for(int j=i+1;j<src.length;j++){
int temp;
if(src[i]<src[j]){
temp=src[j];
src[j]=src[i];
src[i]=temp;
}
}
}
}
System.out.println("冒泡排序(降序)如下,耗时:"+ (System.currentTimeMillis() - start));
}
/**
* 选择排序
* 思想：对待排序的记录序列进行n-1编处理，第1编处理是将L[1..n]中最小者与L[1]交互位置第2编处理是将
* L[2..n]中最小者与L[2]交换位置，...,第i编处理是将L[i..n]中最小者与L[i]交互位置，这样，经过i编处理
* 后，前i个记录的位置就已经按从小到大顺序排序好了。
* 当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大这与其首记录交互位置，按降序排序处理
* @param src 待排序数组
*/
private static void doChooseSort(int[] src){
long start = System.currentTimeMillis();
for(int k=0;k<1000000;k++){
int temp;
for(int i=0;i<src.length;i++){
temp=src[i];
//最小数下标
int smallLocation=i;
for(int j=i+1;j<src.length;j++){
if(src[j]<temp){
//取出最小数
temp=src[j];
//最小数下标
smallLocation=j;
}
}
src[smallLocation]=src[i];
src[i]=temp;
}
}
System.out.println("选择排序如下,耗时:"+ (System.currentTimeMillis() - start));
}

/**
* 插入排序 (while循环)
* @param src 待排序数组
*/
private static void doInsertSortWhile(int[] src){
long start = System.currentTimeMillis();
for(int k=0;k<1000000;k++){
for(int i=1;i<src.length;i++){
int temp = src[i];
int j=i;
while(src[j-1]>temp){
src[j]=src[j-1];
j--;
if (j<=0) break;
}
src[j]=temp;
}
}
System.out.println("插入排序 (while循环)如下,耗时:"+ (System.currentTimeMillis() - start));
}
/**
* 插入排序 (for循环)
* @param src 待排序数组
*/
private static void doInsertSortfor(int[] src){
long start = System.currentTimeMillis();
for(int k=0;k<1000000;k++){
for(int i=1;i<src.length;i++){
int temp=src[i];
int j;
for (j=1;j>0;j--){
if(src[j-1]>temp){
src[j]=src[j-1];
}else{
break;
}
}
src[j]=temp;
}
}
System.out.println("插入排序 (for 循环)如下,耗时:"+ (System.currentTimeMillis() - start));
}

public static void main(String[] args){
int[] src=new int[]{3,5,1,2,7,8,4};

//冒泡排序(升序)
TestSort.toBubbleSortAsc(src);
for(int i=0;i<src.length;i++){
System.out.print(src[i]+" ");
}
//冒泡排序(降序)
System.out.println();
TestSort.toBubbleSortDesc(src);
for(int i=0;i<src.length;i++){
System.out.print(src[i]+" ");
}
//选择排序
System.out.println();
TestSort.doChooseSort(src);
for(int i=0;i<src.length;i++){
System.out.print(src[i]+" ");
}
//插入排序 (while循环)
System.out.println();
TestSort.doInsertSortWhile(src);
for(int i=0;i<src.length;i++){
System.out.print(src[i]+" ");
}
//插入排序 (for循环)
System.out.println();
TestSort.doInsertSortfor(src);
for(int i=0;i<src.length;i++){
System.out.print(src[i]+" ");
}

}
}