算法~~~

解决某个实际问题的过程和方法

一.排序算法

1.冒泡排序

每次从数组中找出最大值放在数组的后面去

public class Test {
    public static void main(String[] args) {
        //1.准备一个数组
        int []  arr = {5,2,1,3};

        //2.定义一个循环排几轮
        for (int i = 0; i < arr.length-1; i++) {
            //                       {5,2,1,3}
            //  i=0 第一轮             0 1 2      比较三次
            //  i=1 第二轮             0 1        比较两次
            //  i=2 第三轮             0          比较一次

            //3.定义一个循环控制每轮比较几次
            for (int j = 0; j < arr.length-i-1; j++) {
                //判断当前位置的元素值，是否大于后一个位置处的元素值，如果大，则交换
                if (arr[j]>arr[j+1]){
                    int temp;
                    temp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }

            }
        }
        System.out.println(Arrays.toString(arr));  //[1, 2, 3, 5]
    }
}

2.选择排序

每轮选择当前位置，开始找出后面的较小值与该位置交换

public class Test2 {
    public static void main(String[] args) {
        //1.准备一个数组
        int[] arr = {5,1,3,2};
        //           0 1 2 3
        //2.控制选择几轮
        for (int i = 0; i < arr.length-1; i++) {
            //i=0 第一轮  j=1,2,3
            //i=1 第二轮  j=2，3
            //i=2 第三轮  j=3
            //3.控制每轮选择几次
            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;
                }
            }       
        }
        System.out.println(Arrays.toString(arr));
    }
}                //[1, 2, 3, 5]

代码优化

public class Test2 {
    public static void main(String[] args) {
        //1.准备一个数组
        int[] arr = {5,1,3,2};
        //           0 1 2 3
        //2.控制选择几轮
        for (int i = 0; i < arr.length-1; i++) {
            //i=0 第一轮  j=1,2,3
            //i=1 第二轮  j=2，3
            //i=2 第三轮  j=3
            int minIndex = i;
            //3.控制每轮选择几次
            for (int j = i+1; j < arr.length ; j++) {
                //判断当前位置是否大于后面位置处的元素值，若大于则交换
                if(arr[minIndex]>arr[j]){
                   minIndex = j;
                }
            }
            if (i != minIndex){
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex]=temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

二.查找算法

二分查找（折半查找）

前提条件：数组中的数据必须是有序的

核心思想：每次排除一半的数据，查询数据的性能明显提高极多

结论：二分查找正常的折半条件应该是开始位置left<=结束位置right

public class Test3 {
    public static void main(String[] args) {
        //1.准备好一个数组
        int[] arr = {7,23,79,81,103,127,131,147};

        System.out.println(binarySearch(arr,127));
    }
    public static int binarySearch(int[] arr,int data){
        //2.定义两个变量，一个站在左边位置，一个站在右边位置
        int left=0;
        int right = arr.length-1;
        //3.定义一个循环控制折半
        while (left<=right){
            //4.每次折半都算出中间位置处的索引
            int middle=(left+right)/2;
            //5.判断当前要找的元素，与中间位置出的元素值的大小情况
            if (arr[middle]<data){
                //往右边找，起始位置（左边位置）=中间位置+1
                left=middle+1;
            }else if (arr[middle]>data){
                //往左边找，截止位置（右边位置）=中间位置-1
                right=middle-1;
            }else {
                //中间位置处的元素值，正好等于我们要找的元素值
                return middle;
            }
        }
        return -1;  //-1特殊值，代表没有找到数据，数组中不存在该数据
    }

}                //5

Java含有binarySearch方法，可以直接调用

public class Test3 {
    public static void main(String[] args) {
        //1.准备好一个数组
        int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};
        System.out.println(Arrays.binarySearch(arr, 127));
    }
}               //5