Java四种排序：冒泡，选择，插入，二分（折半插入）

public class Test{
//    public static void main(String[] args) {
//        Test t=new Test();
        public static void bubbleSort(int[] source){
            // 交换类排序思想： 两两比较待排序的关键字，发现记录相反则交换，直到没有反序的记录。
            for(int i = source.length - 1; i > 0; i--){
                for(int j = 0; j < i; j++){
                    if(source[j] > source[j + 1]){
                        swap(source, j, j+1);
                    }
                }
            }
        }
 
         
        public static void selectSort(int[] source){
            // 选择类排序思想：首先在未排序的序列中找到最小元素，存放到排序序列的起始位置，
            // 然后再从剩余未排序的元素中找到下一个最小元素,放到已排序序列的末尾。
            for (int i = 0; i < source.length; i++){
                for (int j = i+1; j < source.length; j++){
                    if (source[j] > source[i]){
                        swap(source, i, j);
                    }
                }
            }
             
        }
        // 从第一个元素开始，该元素可以认为已经被元素
        // 取出下一个元素，在已经拍序的元素中从后往前扫描，如果该元素大于新一个，则将该元素移到下一个
        public static void insertSort(int[] source){
            for (int i = 1; i < source.length; i++){
                for (int j = i ; (j > 0) && (source[j] < source[j - 1]); j--){
                    swap(source, j, j-1);
                }
                 
            }
        }
        public static void halfSort(int[] source){
            // 二分查找(折半插入)排序思想： 对于第j个元素而言，前面j-1个元素已经有序。
            //在有序的队列里面先折半查找出待插入的位置，再统一后移。最后插入要插入的元素。
            int temp, low, high, mid;
            for (int i =1; i<10; i++){
                temp = source[i];
                low = 0;
                high = i-1;
                while (low <= high){
                    mid = (low + high) / 2;
                    if (source[mid] > temp)
                        high = mid - 1;
                    else
                        low = mid + 1;
                }
                for (int j = i+1; j > high; j--){
                    source[j+1] = source[j];
                }
                source[high+1] = temp;
            }
        }
         
        private static void swap(int[] source, int x, int y){
            int temp = source[x];
            source[x] = source[y];
            source[y] = temp;
        }
 
        public static void main(String[] args){
            int[] a = {4, 2, 1, 3, 4, 6, 7, 8, 0};
            int i;
            bubbleSort(a);
            for (i = 0;i<a.length;i++){
                System.out.printf("%d ", a[i]);
            }
        }
}

 

1、冒泡算法原理:

冒泡排序算法的一般性策略：搜索整个值列，比较相邻元素，如果两者的相对次序不对，则交换它们，其结果是最大值“想水泡一样”移动到值列的最后一个位置上，这也是它在最终完成排序的值列中合适的位置。然后再次搜索值列，将第二大的值移动至倒数第二个位置上，重复该过程，直至将所有元素移动到正确的位置上。

2、二分算法原理:

（1）前提:二分查找的前提是需要查找的数组必须是已排序的，我们这里的实现默认为升序

（2）原理：将数组分为三部分，依次是中值（所谓的中值就是数组中间位置的那个值）前，中值，中值后；将要查找的值和数组的中值进行比较，若小于中值则在中值前面找，若大于中值则在中值后面找，等于中值时直接返回。然后依次是一个递归过程，将前半部分或者后半部分继续分解为三部分。可能描述得不是很清楚，若是不理解可以去网上找。从描述上就可以看出这个算法适合用递归来实现，可以用递归的都可以用循环来实现。所以我们的实现分为递归和循环两种，可以根据代码来理解算法