查找算法
基本查找
package searchdemo;
public class SearchDemo1 {
public static void main(String[] args) {
//基本查找
int[] arr = {131,127,147,81,103,23,7,79};
boolean b = basicSearch(arr, 81);
System.out.println(b);
}
public static boolean basicSearch(int[] arr,int number){
for (int i = 0; i < arr.length; i++) {
if(number == arr[i])
return true;
}
return false;
}
}
package searchdemo;
import java.util.ArrayList;
public class SearchDemo2 {
public static void main(String[] args) {
//基本查找,元素无重复
int[] arr = {131,127,147,81,103,23,7,79};
ArrayList<Integer> list = basicSearch(arr, 81);
if(list == null){
System.out.println(false);
}else{
System.out.println(list);
}
}
//如果返回多个数据,则将数据放到数组或集合当中
public static ArrayList<Integer> basicSearch(int[] arr, int number){
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < arr.length; i++) {
if(number == arr[i]){
list.add(i);
}
}
return list;
}
}
二分查找/折半查找
package searchdemo;
public class SearchDemo3 {
public static void main(String[] args) {
//折半查找
//min和max表示当前要查找的范围,mid是在min和max中间.
int[] arr = {7,23,79,81,103,127,131,147};
System.out.println(binarySearch(arr,81));
}
public static int binarySearch(int[] arr,int number){
int min = 0;
int max = arr.length-1;
while(true){
if(min > max){
return -1;
}
int mid = (min + max) / 2;
if(arr[mid] > number){
max = mid - 1;
}else if(arr[mid] < number){
min = mid + 1;
}else{
return mid;
}
}
}
}
插值查找
mid尽可能的靠近要查找的数据,但是要求数据尽可能的分布均匀
斐波那契查找
根据黄金分割点来计算mid指向的位置
分块查找
**分块原则1:**前一块中的最大数据,小于后一块中所有的数据(块内无序,快间有序)
**分块原则2:**块数数量一般等于数字的个数开根号.比如:16个数字一般为分为4块左右
**核心思路:**先确定查找的元素在哪一块,然后在块内挨个查找
package searchdemo;
public class BlockSearch {
public static void main(String[] args) {
int[] arr = {16,5,9,12,21,18,
32,23,37,26,45,34,
50,48,61,52,73,66};
Block b1 = new Block(16,0,5);
Block b2 = new Block(45,6,11);
Block b3 = new Block(73,12,17);
Block[] blockArr = {b1,b2,b3};
int number = 32;
int flag = -1;
int indexBlock = findIndexBlock(blockArr, number);
if(indexBlock == -1){
System.out.println(false);
}
boolean flagg = false;
for (int i = blockArr[flag].getStartIndex(); i <= blockArr[flag].getEndIndex(); i++){
if(number == arr[i]){
flagg = true;
System.out.println(true);
break;
}
}
if(!flagg){
System.out.println(false);
}
}
private static int findIndexBlock(Block[] blockArr,int number){
for (int i = 0; i < blockArr.length; i++) {
if(blockArr[i].getMax() < number) {
continue;
}else if(blockArr[i].getMax() >= number){
return i;
}
}
return -1;
}
}
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 + "}";
}
}
分块查找的扩展
package searchdemo;
public class BlockSearchDemo2 {
public static void main(String[] args) {
int[] arr = {27,22,30,40,36,
13,19,16,20,
7,10,
43,50,48};
int number = 30;
BlockSearch2 block1 = new BlockSearch2(22,40,0);
BlockSearch2 block2 = new BlockSearch2(13,20,5);
BlockSearch2 block3 = new BlockSearch2(7,10,9);
BlockSearch2 block4 = new BlockSearch2(43,50,11);
BlockSearch2[] blockArr = {block1,block2,block3,block4};
int index = findIndex(blockArr, number);
if(index == -1) {
System.out.println(false);
}else{
boolean flag = false;
for (int i = blockArr[index].getIndex(); i < blockArr[index + 1].getIndex(); i++) {
if(number == arr[i]){
flag = true;
System.out.println(true);
break;
}
}
if(!flag){
System.out.println(false);
}
}
}
private static int findIndex(BlockSearch2[] blockArr,int number){
for (int i = 0; i < blockArr.length; i++) {
if(number >= blockArr[i].getMin() && number <= blockArr[i].getMax()){
return i;
}
}
return -1;
}
}
class BlockSearch2 {
private int min;
private int max;
private int index;
public BlockSearch2() {
}
public BlockSearch2(int min, int max, int index) {
this.min = min;
this.max = max;
this.index = index;
}
/**
* 获取
* @return min
*/
public int getMin() {
return min;
}
/**
* 设置
* @param min
*/
public void setMin(int min) {
this.min = min;
}
/**
* 获取
* @return max
*/
public int getMax() {
return max;
}
/**
* 设置
* @param max
*/
public void setMax(int max) {
this.max = max;
}
/**
* 获取
* @return index
*/
public int getIndex() {
return index;
}
/**
* 设置
* @param index
*/
public void setIndex(int index) {
this.index = index;
}
public String toString() {
return "BlockSearch2{min = " + min + ", max = " + max + ", index = " + index + "}";
}
}
扩展的分块查找(查找过程中还需要添加数据)