Java编程---冒泡排序和选择排序以及二分法查找详细介绍及代码实现。

冒泡排序

假设有 5 个数字 3，1，6，2，5 在一个 int 数组中，要求按从小到大排序输出，采用冒泡排序算法是怎么实现的？
原理：冒泡排序的算法是这样的，首先从数组的最左边开始，取出第 0 号位置（左边）的数据和第 1 号位置（右边）的数据，如果左边的数据大于右边的数据，则进行交换，否而不进行交换。接下来右移一个位置，取出第 1 个位置的数据和第 2 个位置的数据，进行比较，如果左边的数据大于右边的数据，则进行交换，否而不进行交换。沿着这个算法一直排序下去，最大的数就会冒出水面，这就是冒泡排序。

从上面我们看到了第一遍比较了 N-1 次，那么第二遍就为 N-2 次比较了，如此类推，比较次数的公式如下：
(N-1) + (N-2)+…+1=((N-1)*N)/2
所以以上总共比较次数为((5-1)*5)/2=10

冒泡排序的实现：

public class ArraySortTest01 {
    public static void main(String[] args) {
    int[] data = {3,1,6,2,5};
    for (int i=data.length-1; i>0; i--) { 
        for (int j=0; j<i; j++) {
            if (data[j] > data[j+1])
                {int temp = data[j];
                 data[j] = data[j+1]; 
                 data[j+1] = temp;
                 }
            }
       }
    for (int i=0; i<data.length; i++) {      
           System.out.println(data[i]);
           }
 }

选择排序

选择排序对冒泡排序进行了改进，使交换次数减少，但比较次数仍然没有减少。假设有 5 个数字 3，1，6，2，5 在一个 int 数组中，要求按从小到大排序输出
采用选择排序，选择排序是这样的，先从左端开始，找到下标为 0 的元素，然后和后面的元素
依次比较，如果找到了比下标 0 小的元素，那么再使用此元素，再接着依次比较，直到比较完
成所有的元素，最后把最小的和第 0 个位置交换。

选择排序的代码实现：

public class ArraySortTest02 {
    public static void main(String[] args) {
    int[] data = {3,1,6,2,5};
    for (int i=0; i<data.length; i++) 
        { int min = i;
        for (int j=i+1; j<data.length; j++)
           { if (data[j] < data[min]) { 
                min = j;
               }
           }
        //进行位置的交换
        if (min != i) {
        int temp = data[i];
        data[i] = data[min];
        data[min] = temp;
        }
    }
    for (int i=0; i<data.length; i++) {   
      System.out.println(data[i]);
      }
    }
}

二分法（折半）查找

如果一个数组已经排好序，那么我们可以采用效率比较高的二分查找或叫折半查找算法。
见示例

假设，我们准备采用二分法取得 18 在数组中的位置
第一步，首先取得数组 0~9 的中间元素
中间元素的位置为：（开始下标 0 + 结束下标 9）/2=下标 4
通过下标 4 取得对应的值 15
18 大于 15，那么我们在后半部分查找
第二步，取数组 4~9 的中间元素
4~9 的中间元素=（下标 4 + 1 +下标 9）/2=下标 7
下标 7 的值为 18，查找完毕，将下标 7 返回即可
以上就是二分或折半查找法，此种方法必须保证数组事先是排好序的，这一点一定要注意。

二分查找的代码实现：

public class BinarySearchTest01 {
    public static void main(String[] args) {
        int[] data = {11,12,13,14,15,16,17,18,19,20};
        int index = binarySearch(data, 18);   
        System.out.println(index);
        }
    //采用折半法查询，必须建立在排序的基础上
    private static int binarySearch(int[] data, int value) {
    //开始下标
    int beginPos = 0;
    //结束下标
    int endPos = data.length - 1;
    while (beginPos <=endPos) {
    int midPos = (beginPos + endPos)/2; 
    if (value == data[midPos]) {
        return midPos;
    }else if (value > data[midPos]) {
     beginPos = midPos + 1;
    }else if (value < data[midPos]) { 
     endPos = midPos - 1;
     }
    }
    return -1;
 }
}