Java中的算法（冒泡排序，选择排序，二分法查找）

排序算法

冒泡排序算法

1、每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。(冒出最大的那个气泡。）

2、核心：

拿着左边的数字和右边的数字比对，当左边 > 右边的时候，交换位置。

原始数据：

6, 4, 8, 7, 5

第一次循环：(最大的跑到右边。)

4, 6, 8, 7, 5 (4和6比较，6 > 4 ，所以6和4交换位置)

4, 6, 8, 7, 5 (虽然不需要交换位置，但6和8还是需要比较一次。)

4, 6, 7, 8, 5 (7和8交换位置)

4, 6, 7, 5, 8 （5和8交换位置）

经过第一次循环，此时剩下参与比较的数据：4, 6, 7, 5

第二次循环：

4, 6, 7, 5 (4和6比较，不需要交换位置)

4, 6, 7, 5 (6和7比较，不需要交换位置)

4, 6, 5, 7 (5和7交换位置)

经过第二次循环，此时剩下参与比较的数据：4, 6, 5

第三次循环：

4, 6, 5 (4和6比较，不需要交换位置 )

4, 5, 6 (6和5交换位置)

经过第三次循环，此时剩下参与比较的数据: 4, 5

第四次循环：

4, 5 (4和5比较，不需要交换位置)

public class Text {
    public static void main(String[] args) {
        int[] array = {6, 4, 8, 7, 5};
        // 5条数据，循环4次。以下的代码可以循4次。( 冒泡排序的外层循环用这种方式)
        for (int i = array.length - 1; i > 0; i--){
            for (int j = 0; j < i; j++){
                if (array[j] > array[j + 1]){
                    //交换位置
                    //array[j]与array[j + 1]交换
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < array.length; i++){
            System.out.print(array[i]);
        }
    }
}

选择排序算法

每一次从这堆“参与比较的数据当中”找出最小值，拿着这个最小值和“参与比较的这堆最前面的元素”交换位置。

选择排序比冒泡排序好在: 每一次的交换位置都是有意义的。

关键点: 选择排序中的关键在于，你怎么找出一堆数据最小的。

参与比较的数据: 3 1 6 2 5

第1次循环之后的结果是:1 3 6 2 5

参与比较的数据:3 6 2 5

第2次循环之后的结果是:2 6 3 5

参与比较的数据:6 3 5

第3次循环之后的结果是:3 6 5

参与比较的数据:6 5

第4次循环之后的结果是:5 6

注意: 5条数据，循环4次

public class Text {
        public static void main(String[] args) {
        int[] arry = {3, 1, 6, 2, 5};
        //5条数据循环4次
        for (int i = 0; i < arry.length - 1; i++){
            /*i的值是0, 1, 2, 3
              i正好是“参加比较的这对数据中”最左边的那个元素的下标。
              i是一个参与比较的这堆数据中的起点下标*/
            //假设起点i下标位置上的元素是最小的
            int min = i;
            for (int j = i + 1; j < arry.length; j++){
                if (arry[j] < arry[min]){
                    min = j;   //最小值的元素下标是i
                }
            }


            //当i和min相等时，表示最初猜测是对的。
            //当i和min不相等时，表示最初猜测是错的,有比这个元素更小的元素
            //需要拿着这个更小的元素和最左边的元素交换位置
            if (min != i){
                //表示存在更小的数据
                //arr[min] 最小的数据
                //arr[i] 最前面的数据
                int temp = arry[min];
                arry[min] = arry[i];
                arry[i] = temp;
            }
        }
        for (int i = 0; i < arry.length; i++){
            System.out.print(arry[i]);
        }
    }
}

查找算法

二分法查找

二分法查找算法是基于排序的基础之上(没有排序的数据是无法查找的）

1、二分法查找建立在排序的基础之上

2、二分法查找效率要高于“一个挨着一个”的这种查找方式。

3、二分法查找的终止条件：一直折半，直到中间的那个元素恰好是被查找的元素。

4、二分法查找原理?

10(0下标) 23 56 89 100 111 222 235 500 600 (下标9) arr数组

目标：找出600的下标

(0 + 9) / 2 ---> 4(中间元素的下标)

arr[4] 这个元素就是中间元素: arr[4]是 100

100 < 600

说明被查找的元素在100的右边。

那么此时开始下标变成:4 + 1

(5 + 9) / 2 --> 7 (中间元素的下标)

arr[7] 对应的是: 235

235 < 600

说明被查找的元素在235的右边。

开始下标又进行了转变: 7 + 1

(8 + 9) / 2 --> 8

arr[8] --> 500

500 < 600

开始元素的下标又发生了变化: 8 + 1

(9 + 9) / 2 --> 9

arr[9]是600，正好和600相等，此时找到了。

二分法示例代码：

public class ArrayUtil {
    public static void main(String[] args) {
        //创建一个数组
        int[] array = {100, 200, 300, 440, 567, 678, 789, 890, 900};
        //调用binarySearch方法
        int index = binarySearch(array, 567);
        System.out.println(index == -1 ? "对不起该元素不存在" : "该元素下标为:" + index);
    }

    /**
     *从数组中查找目标元素的下标
     * @param arr  被查找的数组（这个必须是已经排序的）
     * @param dest  目标元素
     * @return  -1表示该元素不存在，其他表示返回该元素下标。
     */
    public static int binarySearch(int[] arr, int dest){
        //开始下标
        int begin = 0;
        //结束下标
        int end = arr.length - 1;
        //开始元素的下标只要在结束元素下标的左边，就有机会继续循环。
        while (begin <= end){
            //中间元素下标
            int mid = (begin + end) / 2;
            if (arr[mid] == dest){
                return mid;
            } else if(mid < dest){
                //目标元素在中间元素的右边
                //开始元素下表示需要发生变化（开始元素的下标需要重新赋值）
                begin = mid + 1;  //一直增
            } else {
                /*arr[mid] > dest
                * 目标在中间元素的左边
                * 修改结束元素的下标*/
                end = mid - 1;//  一直减
            }
        }
        return -1;
    }
}

Arrays工具类的使用

所有的方法都是静态的，直接调类名使用

主要使用两个方法：

二分法查找 ， 排序

排序：Arrays.sort();

二分法查找：Arrays.binarySearch();

import java.util.Arrays;

public class ArraysText {
    public static void main(String[] args) {
        int[] array = {12, 43, 54, 56, 78, 345, 674, 234, 14, 54};
        //排序
        Arrays.sort(array);
        //输出
        for (int i = 0; i < array.length; i++){
            System.out.print(array[i] + " ");
        }
        //二分法查找，建立在排序的基础上
        int index = Arrays.binarySearch(array, 12);
        System.out.println();
        System.out.println(index);
        System.out.println(index < 0 ? "找不到" : "找到了");
    }
}

​