下面这个程序是先定义一个整型数组，然后将其中的元素反序赋值，再用冒泡排序进行排序以后用二分查找来查找其中是否有某个数，返回值为-1时表示这个数可能小于这个数组的最小值或大小这个数组的最大值，-2表示这个数比这个数组的最小值大，最大值小，但是数组中不包含这个数，代码如下：
package com.jll.sort;
public class ErFenSort {
static int[] unsorted;
static int[] sorted;
//测试
public static void main(String[] args) {
ErFenSort efs = new ErFenSort(10);
long start = System.currentTimeMillis();
buddleSort();
long end = System.currentTimeMillis();
System.out.println(end-start);
for(int i=0;i<unsorted.length;i++){
System.out.print(unsorted[i]+" ");
}
System.out.println();
int index = search(2);
System.out.println(index);
sorted = insert(3);
for(int i=0;i<sorted.length;i++){
System.out.print(sorted[i]+" ");
}
}
public ErFenSort(int n) {
unsorted = new int[n];
for(int i=0;i<n;i++){
unsorted[n-i-1] = i;
}
}
//二分查找
public static int search(int index){
int head=1;
int tail=unsorted.length-1;
int middle = 0;
int turn = 0;
while(head<=tail){
middle = (tail+head)/2;
if(index==unsorted[middle]){
turn = middle+1;
break;
}else if(index < unsorted[middle]&&index >= unsorted[head]){
// middle=(middle+head)/2;
tail = middle-1;
continue;
}else if(index>unsorted[middle]&&index<=unsorted[tail]){
// middle=(middle+tail)/2;
head = middle+1;
continue;
}else if(index<head||index>tail){
turn = -1;
break;
}else{
turn = -2;
break;
}
}
return turn;
}
//冒泡排序
public static void buddleSort(){
for(int i=0;i<unsorted.length;i++){
for(int j=0;j<unsorted.length-i-1;j++){
if(unsorted[j]>unsorted[j+1]){
int temp = unsorted[j];
unsorted[j]=unsorted[j+1];
unsorted[j+1]=temp;
}
}
}
}
//插入
public static int[] insert(int index){
int[] intArray = new int[unsorted.length+1];
int insert = 0;
for(int i=0;i<unsorted.length;i++){
if(index <= unsorted[i]){
insert = i;
break;
}
}
if(insert==0){
if(index<unsorted[0]){
for(int i=1;i<intArray.length;i++){
intArray[i]=unsorted[i-1];
}
intArray[0]=index;
}else if(index>unsorted[unsorted.length-1]){
for(int i=0;i<unsorted.length;i++){
intArray[i]=unsorted[i];
}
intArray[unsorted.length]=index;
}
}else{
for(int i=0;i<insert;i++){
intArray[i] = unsorted[i];
}
intArray[insert]=index;
for(int j=insert+1;j<intArray.length;j++){
intArray[j]=unsorted[j-1];
}
}
return intArray;
}
}
输出结果为：用时为3；
冒泡排序是最简单，但效率最低的一种排序算法，因为他把所有的数据都两两进行了比较，从冒泡排序中进行优化，得到了选择排序，选择排序是把比较得到的比较小的值进行标记，然后循环一次结束将标记的位置和前面被比较的位置的值进行交换，虽然比较的次数没有减少，但是数值交换的次数变为了常数，即当有N个数进行比较时，最多交换N-1次，下面给出代码：
package com.jll.sort;
public class SelectSort {
public int[] select(int[] unsorted){
int temp=0;
int index=0;
for(int i=0;i<unsorted.length;i++){
temp = unsorted[i];
for(int j=i+1;j<unsorted.length;j++){
if(temp>unsorted[j]){
temp=unsorted[j];
index=j;
}
}
if(temp<unsorted[i]){
unsorted[index]=unsorted[i];
unsorted[i]=temp;
}
}
return unsorted;
}
}
给出测试类：
package com.jll.sort;
public class TestSelectSort {
static int[] unsorted;
public static void main(String[] args) {
new TestSelectSort(10);
for(int i=0;i<unsorted.length;i++){
System.out.print(unsorted[i]+" ");
}
System.out.println();
long start = System.currentTimeMillis();
// System.out.println(start);
SelectSort ts = new SelectSort();
long end = System.currentTimeMillis();
// System.out.println(end);
unsorted = ts.select(unsorted);
for(int i=0;i<unsorted.length;i++){
System.out.print(unsorted[i]+" ");
}
System.out.println();
System.out.println(end-start);
}
public TestSelectSort(int n){
unsorted = new int[n];
for(int i=n;i>0;i--){
unsorted[n-i]=i;
}
}
}
输出结果：用时为1；在测试的时候用的是同一台电脑，数据项都为10，最开始都是反序排列，数据项的值都是相同的；当然，机器性能不一样，结果也不一样，数据不同，结果也不同。
接下来介绍插入排序，插入排序是将其中某项做为一个标记，假设这个标记的左边部分是排好顺序的，只要从标记位置开始往左边合适的位置插入即可，这时需要把标记的位置让出来，把从要插入的位置到标记左边第一个位置的值都向后移动一位，这样每次外层循环调用一次，左边排好的对象就多了一个。下面给出代码：
package com.jll.sort;
public class InsertSort {
public int[] sort(int[] unsorted){
for(int i=1;i<unsorted.length;i++){
int temp=0;
int index=0;
for(int j=i-1;j>=0;j--){
if(unsorted[i]>unsorted[j]){
// temp=unsorted[j+1];
index=j;
break;
}
}
temp=unsorted[i];
for(int k=i;k>index;k--){
unsorted[k]=unsorted[k-1];
}
unsorted[index]=temp;
}
return unsorted;
}
}
测试类：
package com.jll.sort;
public class TestInsertSort {
static int[] unsorted;
public static void main(String[] args) {
TestInsertSort tis = new TestInsertSort(10);
InsertSort insertSort = new InsertSort();
unsorted = insertSort.sort(unsorted);
for(int i=0;i<unsorted.length;i++){
System.out.print(unsorted[i]+" ");
}
}
public TestInsertSort(int n){
unsorted = new int[n];
for(int i=n;i>0;i--){
unsorted[n-i]=i;
}
}
}
输出结果：
稳定性:
有些时候，排序要考虑数据项拥有相同关键字的情况，这种情况下，则只需要算法对需要排序的数据进行排序，让不需要排序的数据保持原来的顺序。某些算法满足这样的需求，它们就可以称为稳定的算法。这次介绍的三种算法都是稳定的。但据我做实验得出来结果好像和理论不太相符，不知道是不是我的代码写的不对，如果有大神知道的话可以告诉我一下，妹子在这里谢过啦！
比较这几种排序算法：
一般情况下几乎不太使用冒泡排序算法，它过于简单了，以至于可以毫不费力地写出来，然而数据量很小的时候它会有些应用的价值。
选择排序虽然把交换次数降到了最低，但比较的次数仍然很大，当数据量很小，并且交换数据相对于比较数据更加耗时的情况下，可以应用选择排序。
在大多数情况下，假设当数据量比较小或基本上有序时，插入排序算法是三种简单养育算法中最好的选择，对于更大数据量的排序来说，快速排序通常是最快的方法。除了在速度方面比较排序算法外，还有一种对各种算法 的衡量标准是算法需要的内存空间有多大，这次介绍的三种算法都可以“就地”完成排序，即除了初始的数组外几乎不需要其它内存空间。所有排序算法都需要一个额外的变量来暂时存储交换时的数据项。