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