学习JAVA的第十二天（基础）

目录

算法

查找算法

基本查找（顺序查找）

二分查找（折半查找）

分块查找

 排序算法

冒泡排序

选择排序

插入排序

快速排序

递归算法 

---

 

算法

                        算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。

---

查找算法

基本查找（顺序查找）

关键：

                        从0索引开始依次向后查找

方法：

 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);    }

                               

本文链接：https://www.kjpai.cn/news/2024-04-01/151875.html，文章来源：网络cs，作者：晨起，版权归作者所有，如需转载请注明来源和作者，否则将追究法律责任！