冒泡排序 二分查找 快速排序 线性查找

二分查找法(折半查找) 

二分查找法 前提 , 数组中的数据 必须是有序的 !

对于一个没有排序的数组, 应先排序 后进行折半查找


需要的参数: 

    1.  最小下标
    2.  最大下标
    3.  中间下标(随着每次折半,中间下标重新运算)(最小下标+最大下标)/2


import java.util.Scanner;
public class Demo4{
    public static void main(String[] args){
        //有序的数组
        int[] arr = {2,3,8,9,15,22,33,36,39,45,55,58,60};
        Scanner input = new Scanner(System.in);
        //用户输入的 , 要寻找的数字
        int number = input.nextInt();

        int minIndex = 0;//最小下标
        int maxIndex = arr.length-1;//最大下标
        int centerIndex = (minIndex+maxIndex)/2;//中间下标

        while(true){
            //拿用户输入的数字 与中间下标再数组中对应的数字进行大小的比较
            if(number<arr[centerIndex]){
                //表示要找的数据在左半部分
                maxIndex = centerIndex-1;
            }else if(number>arr[centerIndex]){
                //表示要找的数据再右半部分
                minIndex = centerIndex+1;
            }else{
                //既不大于又不小于 ,表示相等, 也就是找到了这个数据, 它的下标是centerIndex
                break;
            }
            //范围缩小后, 继续运算中间下标的值
            centerIndex = (minIndex+maxIndex)/2;
            //找不到的情况为: 最大下标小于最小下标
            if(maxIndex<minIndex){
                centerIndex = -1;
                break;
            }




        }

        //找到的数据的下标为centerIndex , 如果找不到centerIndex为-1

    }
}

冒泡排序 重点中的重点

升序排列的口诀: 
    N个数字来排队
    两两相比小靠前,
    外层 循环length-1
    内层循环length-i-1

降序排序的口诀:
    N个数字来排队
    两两相比大靠前,
    外层 循环length-1
    内层循环length-i-1
------------
标准升序排列模版代码:
案例: 

public class Demo3{
    public static void main(String[] args){
        int[] arr = {22,11,14,3,2,6,10,22,81,111,155,66};
        int temp;
        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]){//降序排列, 只需要 把大于号更改为小于号即可
                    //表示左边的数据较大, 需要移动
                    //1.    先将j+1下标 备份到temp变量
                    temp = arr[j+1];
                    //2.    将j+1下标的数据 更改为j下标的数据
                    arr[j+1] = arr[j];
                    //3.    将备份的数据 , 放到j的位置
                    arr[j] = temp;
                }
            }
        }

        //通过之前学习的遍历输出操作 进行排序后的输出

        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" , ");
        }

    }
}

线性查找

循环遍历 查找 

从最小下标 到最大下标 , 依次比较, 发现相同 则表示找到数据,   
到最后依然没有找到, 则表示数据不存在


 * 在一个数组中查找元素的位置
 * @param arr 查找数据的数组对象
 * @param data 要查找的数据
 * @return  查找到的下标. 如果找不到则返回-1
 */
public static int find(int[] arr,int data) {
    for (int i = 0; i < arr.length; i++) {
        if(arr[i]==data) {
            return i;
        }
    }
    return -1;
}

快速排序算法 冒泡改良版 重点

案例: 

    /**
 * 快速排序
 * @param arr  要排序的数组
 * @param l 最小下 标
 * @param h 最大下标
 */
public static void sort(int[] arr,int l,int h) {

    int i=l;
    int j=h;
    //计算中间的下标
    int p=(i+h)/2;
    //将中间下标的数据 先临时的存储到基准变量上
    int temp = arr[p];

    /**
     * 循环:  从i-->p  然后 从p-->j  
     *      直到i不再小于j , 则循环结束
     */
    while(i<j) {
        /**
         * 循环从i到p去寻找数据 ,看是否有大于等于基准值的数据 , 如果有 则不再循环 i就是找到的位置
         */
        while(i<p&&arr[i]<temp) {
            i++;
        }
        /**
         * 找到的大于等于基准值的数据 存储到之前p的位置
         * 然后把p的位置 改为该元素之前的位置
         */
        if(i<p) {
            arr[p] = arr[i];
            p = i;
        }

        /**
         * 循环从p到j去寻找数据 ,看是否有小基准值的数据 , 如果有 则不再循环 j就是找到的位置
         */
        while(p<j&&arr[j]>=temp) {
            j--;
        }
        /**
         * 找到的小于基准值的数据 存储到之前p的位置
         * 然后把p的位置 改为该元素之前的位置
         */
        if(p<j) {
            arr[p] = arr[j];
            p = j;
        }
    }
    //本次左右分好后, 将基准变量放在  i和j和p重叠的位置
    arr[p] = temp;
    System.out.println(Arrays.toString(arr));

    /**
     * 再分别对左右两边的部分, 进行再次分大小 , 使用递归
     */
    if(p-l>1) {
        sort(arr,l,p-1);
    }
    if(h-p>1) {
        sort(arr,p+1,h);
    }
}

public static void main(String[] args) {
    int[] arr = {20,30,10,5,18,26,55,66,77,15,16};
    sort(arr, 0, arr.length-1);
    System.out.println(Arrays.toString(arr));
}