常用的排序算法及思想

冒泡排序：

冒泡排序的核心点：

    每次两两比较找出当前最大值冒出到当前最后面即可！

冒泡排序的实现核心：

    1、确定总共需要冒几轮：数组的长度-1

    2、每轮两两比较

小结:1、确定总共几轮：数组的长度-1

        2、每轮两两比较。数组的长度-i-1次

public class Demo {
    public static void main(String[] args) {
        int[] arr= new int[]{11,33,22,55};
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j <arr.length-i-1 ; j++) {
                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));
    }
}

选择排序：

选择排序的核心点：（依次选出每一个元素）
    选择排序的思想：从当前位置开始找出后面较小值与该位置交换。

    选择排序的实现思路：

    1、控制选择几轮：数组的长度-1

    2、控制每轮从当前位置开始比较几次。

小结：1、从当前位置开始找出后面的较小值与该位置交换。

           2、控制选择几轮：数组的长度-1

           3、以当前位置作为基准，从下一个元素开始遍历寻找出较小值与当前位置交换即可。

public class Demo01 {
    public static void main(String[] args) {
        int[] arr={1,4,3,5};
        //1、定义一个循环控制选择几轮
        for (int i = 0; i <arr.length-1 ; i++) {
            int temp=arr[i];
            //2、定义一个循环控制每轮比较几次，一定是以当前位置与后面元素比较
            for (int j = i+1; j < arr.length; j++) {
                //3、拿当前位置与j指定的元素进行大小比较，后面较小的位置就交换位置
                if (arr[j]<arr[i]){
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        System.out.println("数组"+ Arrays.toString(arr));
    }
}

二分查找：
正常查找：从第一个元素开始遍历，一个一个的往后找，综合查找比较耗时
二分查找：前提：对于数组是有要求的，数组必须是有序的
每次先于中间的元素进行比较，如果大于往右边找，如果小于往左边找，如果等于就返回该元素的索引位置
   如果没有该元素，返回-1，综合性能比较好！
小结：
   定义一个方法，记录开始的索引位置和结束的索引位置。
   取出中间索引位置的值，拿出元素与中间位置的值进行比较，如果小于中间值，结束位置=中间索引-1
   取出中间索引位置的值，拿出元素与中间位置的值进行比较，如果大于中间值，开始位置=中间索引+1
   循环正常执行的条件是：开始位置<=结束位置索引，否则说明寻找完毕但是还是没有该元素值返回了。

package com.yyy._015二分排序;

public class Demo01 {
    public static void main(String[] args) {
        int[] arr = {10, 14, 17, 19, 50, 90, 100, 104};
        int index = binarySearch(arr, 50);
        System.out.println(index);
    }

    /**二分查找
     * 正常查找：从第一个元素开始遍历，一个一个的往后找，综合查找比较耗时
        二分查找：前提：对于数组是有要求的，数组必须是有序的
        每次先于中间的元素进行比较，如果大于往右边找，如果小于往左边找，如果等于就返回该元素的索引位置
        如果没有该元素，返回-1，综合性能比较好！
     小结：
        定义一个方法，记录开始的索引位置和结束的索引位置。
        取出中间索引位置的值，拿出元素与中间位置的值进行比较，如果小于中间值，结束位置=中间索引-1
        取出中间索引位置的值，拿出元素与中间位置的值进行比较，如果大于中间值，开始位置=中间索引+1
        循环正常执行的条件是：开始位置<=结束位置索引，否则说明寻找完毕但是还是没有该元素值返回了。
     */
    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]) {
                //当前元素大于中间元素，往右找，起始位置要改变
                start = middleIndex + 1;
            } else if (number <arr[middleIndex] ) {
                //当前元素小于中间元素，往左找，末尾位置要改变
                end = middleIndex - 1;
            } else if (number == arr [middleIndex]) {
                return middleIndex;
            }
        }
        //若是没有找到，则返回-1
        return -1;
    }
}