java 冒泡排序 二分查找 选择排序 插入排序

下面这个程序是先定义一个整型数组，然后将其中的元素反序赋值，再用冒泡排序进行排序以后用二分查找来查找其中是否有某个数，返回值为-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;
        }
    }
}

输出结果：

稳定性:

有些时候，排序要考虑数据项拥有相同关键字的情况，这种情况下，则只需要算法对需要排序的数据进行排序，让不需要排序的数据保持原来的顺序。某些算法满足这样的需求，它们就可以称为稳定的算法。这次介绍的三种算法都是稳定的。但据我做实验得出来结果好像和理论不太相符，不知道是不是我的代码写的不对，如果有大神知道的话可以告诉我一下，妹子在这里谢过啦！

比较这几种排序算法：

一般情况下几乎不太使用冒泡排序算法，它过于简单了，以至于可以毫不费力地写出来，然而数据量很小的时候它会有些应用的价值。

选择排序虽然把交换次数降到了最低，但比较的次数仍然很大，当数据量很小，并且交换数据相对于比较数据更加耗时的情况下，可以应用选择排序。

在大多数情况下，假设当数据量比较小或基本上有序时，插入排序算法是三种简单养育算法中最好的选择，对于更大数据量的排序来说，快速排序通常是最快的方法。除了在速度方面比较排序算法外，还有一种对各种算法 的衡量标准是算法需要的内存空间有多大，这次介绍的三种算法都可以“就地”完成排序，即除了初始的数组外几乎不需要其它内存空间。所有排序算法都需要一个额外的变量来暂时存储交换时的数据项。