学习JAVA的第十二天（基础）-CSDN博客

 public static boolean basicSearch(int[] arr,int number) {
        //基本查找  遍历数组查找所需结果
        for (int i = 0; i < arr.length; i++) {
            if(number == arr[i]){
                return true;
            }
        }
        return false;
    }

}

二分查找（折半查找）

关键：

数组中的数据是有序的

每次排除一半的查找范围，节省查找次数

方法：

    public static int BinarySearch(int[] arr,int number)  {
        //定义变量确定查找范围 最小肯定是0索引的
        int min = 0;
        //最大的索引是数组长度-1
        int max = arr.length-1;
        //开始循环查找数据，利用while循环，查找出索引直接返回结果
        while(true){
            if(min > max){
                //返回-1，调用时可以将-1与0作比较，得出数据索引是否存在
                return -1;
            }
            //中间位置
            int mid = (min + max) / 2;
            //arr[mid]>number
            if(arr[mid]>number){
                max = mid - 1;
            }//arr[mid]<number
            else if(arr[mid]<number){
                min = mid + 1;

            }else{
                return mid;
            }
        }

    }

分块查找

关键：

块内无序，块间有序。

一般分块是按照数组长度的开根号

具体问题，具体分析

方法：

//判断number在哪个块中
    private static int findIndexBlock(Block[] bArr,int number){
        //循环判断number在哪个块中
        for (int i = 0; i < bArr.length; i++) {
            if(number <= bArr[i].getMax()){
                return i;
            }
        }
        return -1;
    }

    //利用分块查找获取索引
    private static int getIndex(Block[] bArr,int[] arr,int number){
        int indexBlock = findIndexBlock(bArr,number);

        //数据不在数组中
        if(indexBlock == -1){
            return -1;
        }
        //数据在数组中  刚才获取了数据所属块的索引
        int startIndex = bArr[indexBlock].getStartIndex();
        int endIndex = bArr[indexBlock].getEndIndex();

        //遍历
        for (int i = startIndex; i <= endIndex; i++) {
            if(arr[i] == number){
                return i;
            }
        }
        return -1;


    }

排序算法

冒泡排序

关键：

将相邻的数据进行比较，小的放前面，大的放后面。

方法：

      for(int i = 0; i < arr.length - 1; i++){
            for (int j = 0; j < arr.length - 1-i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }

选择排序

关键：

从0索引开始，用每个索引的元素与后面依次比较，小的放前面，大的放后面。

方法：

        //循环次数
        for(int i = 0; i < arr.length-1;i++){
            //从哪个索引开始比较
            for (int j = 1+i; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int tmp = arr[i];
                    arr[i] = arr[j ];
                    arr[j ] = tmp;
                }
            }
        }

插入排序

关键：

将0索引到n索引看成有序的，n+1到最大索引是无序的。遍历无序数据，将其插入有序数据的合适位置

方法：

//确定无序数据的开始索引，依次插入有序数据中
        for (int i = startIndex; i < arr.length; i++) {
            int j = i;
            //相当于依次向左比较，直至到0索引为止
            while(j > 0 && arr[j] < arr[j-1]){
                int tmp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
                j--;
            }


        }

快速排序

关键：

将0索引的数据作为基准数，左边都是比基准数小的，右边都是比基准数大的

方法：

 public static void QuickSort(int[] arr, int startIndex, int endIndex) {
        //定义两个查找的范围 start~end
        int start = startIndex;
        int end = endIndex;
        //递归的出口
        if(end < start){
            return;
        }
        //0索引为基准数
        int baseNumber = arr[startIndex];


        while(end != start){
            while (true) {
                if (start >= end || arr[end] < baseNumber) {
                    break;
                }
                end--;
            }
            while (true) {
                if (start >= end || arr[start] > baseNumber) {
                    break;
                }
                start++;
            }


            int tmp = arr[start];
            arr[start] = arr[end];
            arr[end] = tmp;
        }
        int tmp = arr[start];
        arr[start] = arr[startIndex];
        arr[startIndex] = tmp;
        //递归条件
        QuickSort(arr,startIndex,start-1);
        QuickSort(arr,start+1,endIndex);


    }

递归算法

方法中调用方法本身的现象

关键：

递归算法一定要有出口，否则内存会溢出

以大化小解决问题

方法：

   //简单的累加递归
 public static int Recursion(int number) {
       if(number == 1){
           return 1;
       }
       return number+Recursion(number-1);
    }

    //简单的求阶乘的递归
    public static int getNumber(int number) {
        if(number == 1){
            return 1;
        }
        return number * getNumber(number-1);

    }