JAVA学习笔记DAY13（简单算法）

1· 冒泡排序

        核心：相邻的数据两两比较，小得放前面，大的放后面

//首先将数据存入数组中
        int[] arr = {3,5,2,1,8,6,9,4,15};

        //进行排序
        int[] arr2 = MPmethod(arr);

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

        private static int[] MPmethod(int[] arr) {
        //最外层
        for (int i = 0; i < arr.length; i++) {
            //内层遍历比较
            for (int j = 0; j <arr.length-1; j++) {
                if(arr[j]>arr[j+1]){
                      int temp=arr[j];
                      arr[j]=arr[j+1];
                      arr[j+1]=temp;
                  }
                }
            }
            return arr;
    }

2·分块查找

分块查找实现步骤：1· 创建数组blockArr存放每一个块对象的信息 ；2·先查找blockArr确定要查找的数据属于哪一块； 3·再单独遍历该块数据即可

分块依据为： 大致块数为所给数据数的平方根，然后根据实际情况调整

int[] arr={15,5,9,12,21,18,
                    32,23,37,26,45,34,
                    50,48,61,52,73,66
        };

        //创建三个块的对象：
        Block b1=new Block(21,0,5);
        Block b2=new Block(45,6,11);
        Block b3=new Block(73,12,17);

        //定义数组用来管理三个块的对象
        Block[] blockArr={b1,b2,b3};

        //定义一个变量用来记录要查找的元素
        int number=66;

        //调用方法，传递索引表，数组，要查找的元素
        int index=getIndex(blockArr,arr,number);
        if(index!=-1){
            System.out.println("找到该数字"+arr[index]);
        }else{
            System.out.println("未找到");
        }
    }

    //利用分块查找的原理，查询number的索引
    private static int getIndex(Block[] blockArr, int[] arr, int number) {
        //判断是否在数组中
        int index=findIndexBlock(blockArr,number);
        if(index!=-1){
            int getIndex=blockArr[index].getStartIndex();
            int endIndex=blockArr[index].getEndIndex();
            for (int i = getIndex; i <=endIndex ; i++) {
                if(number==arr[i]){
                    return i;
                }
            }
        }
        return -1;
    }

    //定义一个方法，用来确定number在哪一块
    public  static int findIndexBlock(Block[] blockArr,int number){
        for (int i = 0; i <3 ; i++) {
            if(number<=blockArr[i].max){
                return i;
            }
        }
        return -1;
    }

    static class  Block{
        private int max; //
        private int startIndex;
        private int endIndex;

        public Block() {
        }

        public Block(int max, int startIndex, int endIndex) {
            this.max = max;
            this.startIndex = startIndex;
            this.endIndex = endIndex;
        }

        public int getMax() {
            return max;
        }

        public void setMax(int max) {
            this.max = max;
        }

        public int getStartIndex() {
            return startIndex;
        }

        public void setStartIndex(int startIndex) {
            this.startIndex = startIndex;
        }

        public int getEndIndex() {
            return endIndex;
        }

        public void setEndIndex(int endIndex) {
            this.endIndex = endIndex;
        }
    }

3·分块查找的拓展

        

无规律的数据查找
27,22,30,40,36,13,19,16,20,7,10,43,50,48
第一步，确定大概分几块
int[] arr={27,22,30,40,36,13,19,16,20,7,10,43,50,48};
System.out.println(arr.length); //14
System.out.println(Math.sqrt(14));// 3.7,根据实际情况分块

int[] arr={
                27,22,30,40,36,
                13,19,16,20,
                7,10,
                43,50,48
        };

        //定义四个Block对象
        Block b1= new Block(22,40,0,4);
        Block b2=new Block(13,20,5,8);
        Block b3=new Block(7,10,9,10);
        Block b4=new Block(43,50,11,13);

        //将分好的块放入Block数组中
        Block[] blocks={b1,b2,b3,b4};

        //定义要查找的数组
        int num=20;

        //以该索引遍历数组
         int index = findArr(blocks, num, arr);
            if(index!=-1){
            System.out.println(arr[index]);
        }else System.out.println("未找到");

    }

    private static int findArr(Block[] blocks, int num, int[] arr) {
        //找到要查询的数组所在块的索引
        int index = getIndex(blocks, num);

        //判断是否存在
        if(index!=-1){
            int startIndex=blocks[index].getStartIndex();
            int endIndex=blocks[index].getEndIndex();
            for (int i = startIndex; i <=endIndex ; i++) {
                if(num==arr[i]){
                    return i;
                }
            }
        }
    return -1;
    }

    //找到所求数字所在的块索引
    private static int getIndex(Block[] blocks, int num) {
        for (int i = 0; i <4 ; i++) {
            if(blocks[i].max>=num && blocks[i].min<=num){
                return i;
            }
        }
        return -1;
    }

    static class Block{
        private int min;
        private int max;
        private int startIndex;
        private int endIndex;

        public Block() {
        }

        public Block(int min, int max, int startIndex, int endIndex) {
            this.min = min;
            this.max = max;
            this.startIndex = startIndex;
            this.endIndex = endIndex;
        }

        public int getMin() {
            return min;
        }

        public void setMin(int min) {
            this.min = min;
        }

        public int getMax() {
            return max;
        }

        public void setMax(int max) {
            this.max = max;
        }

        public int getStartIndex() {
            return startIndex;
        }

        public void setStartIndex(int startIndex) {
            this.startIndex = startIndex;
        }

        public int getEndIndex() {
            return endIndex;
        }

        public void setEndIndex(int endIndex) {
            this.endIndex = endIndex;
        }
    }

4·选择排序

//选择排序：从0索引开始，拿着每一个索引上的元素跟后面的元素依次比较，小的放前面，大的放后面
        // 4 9 6 7 1 546 45
//        1 9 6 7 4 546 45
//            1 4 6 9 546 45

        int[] arr1={4,6,9,7,1,546,45};

        //使用选择排序
        int[] ints = XZMethod(arr1);

        //遍历验证
        for (int i = 0; i < ints.length; i++) {
            System.out.print(ints[i]+" ");
        }
    }

    private static int[] XZMethod(int[] arr1) {
        for (int i = 0; i < arr1.length; i++) {
            for (int j =i; j <arr1.length; j++) {
                if(arr1[i]>arr1[j]){
                    int temp=arr1[i];
                    arr1[i]=arr1[j];
                    arr1[j]=temp;
                }
            }
        }
    return arr1;
    }