邢台网站123那个推广平台好用

（以下内容全部来自上述课程）

1.查找算法

1.基本查找

数据无 顺序要求。

package search;public class BasicSearchDemo1 {public static void main(String[] args) {//基本查找/顺序查找//核心：//从0索引开始挨个往后查找//需求：定义一个方法利用基本查找，查询某个元素是否存在//数据如下：{131, 127, 147, 81, 103, 23, 7, 79}int[] arr = {131, 127, 147, 81, 103, 23, 7, 79};int number = 82;System.out.println(basicSearch(arr, number));}//参数：//一：数组//二：要查找的元素//返回值：//元素是否存在public static boolean basicSearch(int[] arr, int number){//利用基本查找，查询某个元素是否存在//数据如下：{131, 127, 147, 81, 103, 23, 7, 79}for(int i = 0; i < arr.length; i++){if(arr[i] == number){return true;}}return false;}
}

2.二分查找/折半查找

• 前提条件：数组中的数据必须是有序的。
  如果数据是乱的，先排序再用二分查找得到的索引没有实际意义，只能确定当前数字在数组中是否存在，因为排序之后数字的位置就可能发生变化了。
• 核心逻辑：每次排除一半的查找范围。
• 提高查找效率

package search;public class BinarySearchDemo1 {public static void main(String[] args) {// 二分查找/折半查找// 核心：// 每次排除一半的查找范围// 前提：数组元素有序// 需求：定义一个方法利用二分查找，查询某个元素是否存在// 数据如下：{1,2,3,4,5,6,7,8,9}int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };int index = binarySearch(arr, 8);System.out.println(index);}public static int binarySearch(int[] arr, int value) {// 定义三个变量记录要查找的范围int min = 0;int max = arr.length - 1;// 循环查找，min大于max时结束查找// 检查中间值是否是要找的// 中间值比要找的值大，说明要找的值在左边// 中间值比要找的值小，说明要找的值在右边// 重新计算min和maxwhile (true) {if (min > max) {return -1;}int mid = (min + max) / 2;if (arr[mid] > value) {max = mid - 1;} else if (arr[mid] < value) {min = mid + 1;} else {return mid;}}}
}

3.插值查找（二分查找优化1----了解）

只能数据分布均匀才能用。

4.斐波那契（二分查找优化2----了解）

5.分块查找

• 分块原则1：前一块中的最大数据，小于后一块中所有的数据。（块内无序，块间有序）
• 分块原则2：块数数量一般等于数字的个数开根号。比如：16个数字一般分为4块左右。
• 核心思路：先确定要查找的元素在哪一块，然后在块内挨个查找。

package search;public class BlockSearchDemo {public static void main(String[] args) {//分块查找//核心：//1、必须要知道索引表的内容//2、先去索引表中找，确定要找的数据在哪一个块中//3、再去这个块中找对应的元素int[] arr = {16, 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 = blockSearch(blockArr, arr, number);System.out.println(index);}//利用分块原理，查询number在哪个块中public static int blockSearch(Block[] blockArr, int[] arr, int number){//1、确认number是在哪一块中int indexBlock = getIndex(blockArr, number);if(indexBlock == -1){//索引表中没有要查找的值return -1;}//2、获取这一块的起始索引和结束索引//Block b1 = new Block(21, 0, 5);//Block b2 = new Block(45, 6, 11);//Block b3 = new Block(73, 12, 17);int startIndex = blockArr[indexBlock].getStartIndex();int endIndex = blockArr[indexBlock].getEndIndex();//3、遍历这一块，获取这一块中的每一个元素for(int i = startIndex; i <= endIndex; i++){if(arr[i] == number){return i;}}return -1;}//定义一个方法。用来确定number在哪一个块中public static int getIndex(Block[] blockArr,int number){//从0索引开始遍历blockArr，如果number小于max，那么就表示number在这个块中for(int i = 0; i < blockArr.length; i++){//判断number是否小于索引表中的最大值//如果在，记录这个值的索引，并结束循环if(number <= blockArr[i].getMax()){return i;}}return -1;}}
//JavaBean
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;}/*** 获取** @return max*/public int getMax() {return max;}/*** 设置** @param max*/public void setMax(int max) {this.max = max;}/*** 获取** @return startIndex*/public int getStartIndex() {return startIndex;}/*** 设置** @param startIndex*/public void setStartIndex(int startIndex) {this.startIndex = startIndex;}/*** 获取** @return endIndex*/public int getEndIndex() {return endIndex;}/*** 设置** @param endIndex*/public void setEndIndex(int endIndex) {this.endIndex = endIndex;}public String toString() {return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";}
}

1.拓展1

6.哈希查找 ---->>拓展2

2.排序算法

1.冒泡排序（相邻-----先最大）

相邻的数据两两比较，小的放前面，大的放后面。

package mysort;public class BubbleDemo1 {public static void main(String[] args) {// 冒泡排序// 核心：// 每次比较相邻的两个元素，如果前一个比后一个大，就交换// 每次比较完毕后，下一次的比较就会少一个元素// 需求：定义一个方法利用冒泡排序，对数组进行排序// 数组如下：{24, 69, 80, 57, 13}int[] arr = {24, 69, 80, 57, 13};bubbleSort(arr);printArr(arr);}public static void bubbleSort(int[] arr) {// 利用冒泡排序，对数组进行排序// 数组如下：{24, 69, 80, 57, 13}// 外层循环控制的是次数：arr.length - 1for (int i = 0; i < arr.length - 1; i++) {// 内存循环控制的是索引：arr.length - 1 - ifor (int j = 0; j < arr.length - 1 - i; j++) {// 比较相邻的两个元素，如果前一个比后一个大，就交换if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}public static void printArr(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}}
}

2.选择排序（0与后-----先最小）

从0索引开始，拿着每一个0索引上的元素跟后面的元素依次比较，小的放前面，大的放后面，以此类推。（数字pk）

package mysort;public class SelectionDemo {public static void main(String[] args) {// 选择排序// 核心：// 每次循环找到最小的元素，放到前面// 需求：定义一个方法利用选择排序，将一个int数组中的数据从小到大排序// 数据如下：{24, 69, 80, 57, 13}int[] arr = {24, 69, 80, 57, 13};selectionSort(arr);printArr(arr);}public static void selectionSort(int[] arr) {// 利用选择排序，将一个int数组中的数据从小到大排序// 数据如下：{24, 69, 80, 57, 13}// 外层循环控制的是次数：arr.length - 1for (int i = 0; i < arr.length - 1; i++) {// 内存循环控制的是索引：i + 1for (int j = i + 1; j < arr.length; j++) {// 比较相邻的两个元素，如果前一个比后一个大，就交换if (arr[i] > arr[j]) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}}public static void printArr(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}}
}

3.插入排序（分两派------无插有）

将0索引的元素到N索引的元素看作是有序的，把N+1索引的元素到最后一个当成是无序的。
遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。
N的范围：0~最大索引

package mysort;public class InsertDemo {public static void main(String[] args) {// 插入排序int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};//1.找到无序的那一组数据是从哪个索引开始的。    2int startIndex = -1;for (int i = 0; i < arr.length; i++) {if (arr[i] > arr[i + 1]) {startIndex = i + 1;break;}}//2.遍历从startIndex开始的数据，依次插入到前面有序的序列中。for (int i = startIndex; i < arr.length; i++) {//问题：如何把arr[i]这个数据插入到前面的有序序列中？//记录要插入的数据的索引int j = i;while (j > 0 && arr[j] < arr[j - 1]) {//交换int temp = arr[j];arr[j] = arr[j - 1];arr[j - 1] = temp;j--;}}printArr(arr);}public static void printArr(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}System.out.println();}
}

4.递归算法（套娃）

指的是方法中调用方法本身的现象。
注意：递归一定要有出口（结束条件），否则就会出现内存溢出。
作用：大事化小，小事化了。

核心：

• 找出口：什么时候不再调用方法。
• 找规则：如何把大问题变成规模较小的问题。

一阶一阶的弹窗，往里加载方法，最后到结束条件把返回值返回给方法的调用者，然后方法一个一个出栈。

5.快速排序（0当原点，左右互换）

先移动end，再移动start。

package mysort;public class QuickSortDemo {public static void main(String[] args) {int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};quickSort(arr, 0, arr.length - 1);printArr(arr);}public static void quickSort(int[] arr, int left, int right) {if (left > right) {return;}int i = left;int j = right;int temp = arr[left];while (i != j) {while (arr[j] >= temp && i < j) {j--;}while (arr[i] <= temp && i < j) {i++;}if (i < j) {int t = arr[i];arr[i] = arr[j];arr[j] = t;}}arr[left] = arr[i];arr[i] = temp;quickSort(arr, left, i - 1);quickSort(arr, i + 1, right);}public static void printArr(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}System.out.println();}
}