冒泡排序：

冒泡排序是一种计算机领域中比较简单的而且是比较常见的排序算法。算法原理就是：重复的访问需要排序的元素列，依次比较两个相邻的元素，如果顺序从大到小或者从小到大位置错误，就将两个数据交换过来。此算法名字的由来是因为越小的元素经由交换慢慢“浮”到数列的顶端（升序或降序），如果碳酸饮料中的二氧化碳的气泡一样最终上浮到顶端一样，故名“冒泡排序”。

如下数组排序：

数组：6,5,4,2,3,1（升序排序）

第一趟（i=0）：    第二趟（i=1）：

第一次比较：5 6 4 2 3 1 第一次比较：4 5 2 3 1 6

第二次比较：5 4 6 2 3 1 第二次比较：4 2 5 3 1 6

第三次比较：5 4 2 6 3 1 第三次比较：4 2 3   5 1 6

扫描二维码关注公众号，回复： 11994384 查看本文章

第四次比较：5 4 2 3 6 1   第四次比较：4    2 3 1 5 6

第五次比较：5 4 2 3 1 6

第三趟（i=2）： 第四趟（i=3）：

第一次比较：2 4 3 1 5 6 第一次比较：2 3 1 4 5 6

第二次比较：2 3 4   1 5 6 第二次比较：2 1 3 4 5 6

第三次比较：2 3 1 4 5 6 （第一次比较，2<3,所以无需交换位置）

第五趟（i=4）:

  第一次比较：1 2 3 4 5 6

第一趟比较中，6比以上集合（数组）中任何一个数都要大，所以在进行完第一次比较之后，6移到了最后，同时在进行第二趟的比较时，由于在第一趟的比较中，最大数（最小数）已经移到了最后，因此在第二趟的比较中无需在和最后一个数进行比较即可，相同的，在后面的

第三趟中，无需和最后两个数进行比较，

第四趟中，无需和最后三个数进行比较，

第五趟中，无需和最后四个数进行比较

在上面的移动过程中，可以发现，比较的趟数“i”是集合（数组）的长度-1，每次比较的次数（5,4,3,2,1）"j"可以使用：集合（数组）长度-趟数-1，在每次比较的时候，从头开始，比较两个数的大小，如果当前的数大于后面的数，两数交换位置。

代码如下：

   public static int[] bubbleMethod(int[] arr){
        //执行的趟数
        for (int i = 0; i < arr.length; i++) {
            //每趟比较的次数
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //判断两个数的大小
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        return arr;
    }

选择排序：

找了个动图来体现一下:

数组：6,5,4,2,3,1（升序排序）[红色数字代表：用来和下一个数据比较的数据蓝色数字代表:待比较的数据]

第一趟（i=0）：(第一个数和后面的数做比较)    第二趟（i=1）：(第二个数和后面的数作比较)

第一次比较：5 6 4 2 3 1 第一次比较：1 2   4 5 3 6

第二次比较：4 5 6 2 3 1 第二次比较：1 2   4 5 3 6

第三次比较：2 4 5 6 3 1 第三次比较：1 2   4 5 3 6

第四次比较：2 4 5 3 6 1   第四次比较：1 2   4 5 3 6

第五次比较：1 2   4 5 3 6

第三趟（i=2）：()     第四趟（i=3）：

第一次比较：1 2   4 5 3 6 第一次比较：1 2   3 4   5    6

第二次比较：1 2   3 4 5   6 第二次比较：1 2   3 4   5 6

第三次比较：1 2   3 5 4 6

第五趟（i=4）:

  第一次比较：1 2 3 4 5 6

第一趟：拿第一个数和后面的所有数作比较，如果第一个数大于后面的数，和后面的数交换位置，继续拿交换后的数接着作比较。

第二趟：由于第一趟循环之后，最小数的数已经放到了第一个位置，所以拿第二个数和后面的数作比较，如果第二个数大于后面的数，和后面的数交换位置，继续拿交换的接着作比较，…………

得规则：

每次拿第i索引元素作比较，先和和第i+1和元素进行比较，i的值不大于数据（集合）长度

public static int[] bubbleMethod(int[] arr){
    for (int i = 0; i < arr.length; i++) {
        for (int j = i+1; j < arr.length; j++) {
           //判断两个数的大小
           if (arr[i]<arr[j]){
               int temp=arr[i];
               arr[i]=arr[j];
               arr[j]=temp;
           }
       }
    }
}

二分查找法：

也叫折半查找算法，查找某一个元素的索引位置。

适用前提：

序列必须是已经排好序的

不考虑元素重复的情况

//定义方法完成二分查找
    public static int find(int[] arr, int a){
        //定义开始和结束
        int i = 0;
        int j = arr.length-1;
        //循环
        while(true){
            //判断
            if(i > j){
                //表示找不到
                return -1;
            }
            //中间值
            int mid = (i+j)/2;
            //比较
            if(arr[mid] == a){
                return mid;
            }else if(arr[mid] < a){
                i = mid + 1;
            }else{
                j = mid - 1;
            }
        }
    }

【Java】Java基础算法之冒泡排序，选择排序和二分查找

冒泡排序：

选择排序：

二分查找法：

猜你喜欢