JavaSE案例 03——经典算法：冒泡，选择，二分查找案例

1 冒泡排序

1. 内容

• 确定总共需要冒几轮：两两比较，只需要冒泡数组长度-1轮

• 每轮两两比较几次

i [轮数]      次数          每轮次数的规律：数组长度-i-1
0               3
1               2
2               1

2. 代码

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[] {55,22,99,88};
        //1.定义一个循环控制总共需要冒泡几轮：数组的长度-1
        for (int i =0;i<arr.length-1;i++){//从0开始，小于几次就遍历几次
            //2.控制每次比较几次
             for (int j =0;j<arr.length-i-1;j++){
                 //i = 0 j =0 1 2
                 //i = 1 j = 0 1
                 //i = 2 j = 0
                 //2.控制每轮比较几次
                 if(arr[j] > arr[j + 1]){
                     //交换位置。大的元素必须后移！
                     //需要中间的一个临时变量存储后一个元素
                     int temp = arr[j+1];
                     arr[j+1] = arr[j];
                     arr[j] = temp;
                 }
            }
        }
        System.out.println("数组："+ Arrays.toString(arr));
    }
}

2 选择排序

1. 内容

• 控制选择几轮：数组的长度-1
• 控制每轮从当前位置开始比较几次
• 和冒泡排序的不同是，每轮选择当前最前面的元素和后面元素进行比较，后面的较小就交换位置

2. 代码

public class SelectSort02 {
    public static void main(String[] args) {
        int[] arr = {5,1,3,2};
        for (int i = 0;i<arr.length-1;i++){
            //定义一个循环控制每轮比较几次，一定是以当前位置开始与后面元素比较
            //当前位置和论数一样,但是是取当前位置后面的数开始循环和当前位置比较
            for (int j = i+1;j<arr.length;j++){

                //i = 0 ,j = 1,2,3
                //i = 1 ,j = 2,3
                //i = 2,j = 2
                //拿当前位置和j指定的元素进行大小比较，后面的较小就交换位置
                if(arr[i]>arr[j]){
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        System.out.println("数组："+ Arrays.toString(arr));
    }
}

3 二分查找

1. 内容：

• 二分查找的前提：对数组是有要求的，数组必须已经排好序
• 每次先于中间的元素进行比较，如果大于往后边找，如果小于往左边找，如果等于就返回该元素索引位置
• 如果没有该元素，返回-1

2. 代码

public class BinarySearch {
    public static void main(String[] args) {
        //需求：找出53号元素的索引值，利用二分查找
        //1.数组
        int [] arr = {10,14,21,38,45,47,53,81,87,99};
        System.out.println(binarysearch(arr, 53));
    }
    
    
    
    
        
     //二分查找的算法实现
    public static int binarysearch(int[] arr,int number){
        //定义起始位置和和结尾位置
        int start = 0;
        int end = arr.length-1;
        //定义一个循环，不断地折中寻找
        while (start<=end){//当开始位置大于结束位置，说明压根就没这值
            //定位出中间元素的索引
            int middleIndex = (start+end)/2;
            //拿当前元素和中间元素进行比较
            if(number> arr[middleIndex]){
                //当前元素大于中间元素，往中间索引的右边+1找，起始位置需要改变
                start = middleIndex+1;
            }else if(number<arr[middleIndex]){
                //当前元素小于中间元素，往左找，其实位置需要改变
                end = middleIndex-1;
            }else if(number == arr[middleIndex]){
                return middleIndex;
            }
        }
        return -1;//循环找不到了，跳出循环，返回-1
    }
}
``