# 查找算法总结：顺序查找，二分查找，分块查找，散列查找，二叉排序树查找

B树用于查找磁盘数据，这里不进行分析

# 顺序查找

java实现：

public static int seqSearch(List<Integer> arr, int key) {
for (int i = 0; i < arr.size(); i++) {
if (arr.get(i) == Integer.valueOf(key)) {
return i;
}
}
return -1;
}

# 二分查找

java实现:

//非递归实现
public static int binSearch(List<Integer> arr, int key, int low, int high) {
int middle = (low + high) / 2;
while (low < high) {
if (arr.get(middle) < key) {
low = middle + 1;
} else if (arr.get(middle) > key) {
high = middle - 1;
} else {
return middle;
}
middle = (low + high) / 2;
}
return -1;
}


//递归实现

/**
* 递归二分查找
* @param arr
* @param key
* @param low
* @param high
* @return
*/
public static int binSearchRecur(List<Integer> arr, int key, int low, int high) {

if (low > high)
return -1;
int middle = (low + high) / 2;
if (arr.get(middle) == key) {
return middle;
}
if (arr.get(middle) < key) {
return binSearchRecur(arr, key, middle + 1, high);
} else {
return binSearchRecur(arr, key, low, middle - 1);
}
}

public class Search {
public static void main(String[] args) {

System.out.println("请输入数组：");
List<Integer> arr = new ArrayList<Integer>();

int key = 0;
Scanner input = new Scanner(System.in);
String strInput = input.nextLine();
String[] inputs = strInput.split(" ");
for (int j = 0; j < inputs.length; j++) {
}

System.out.println("请输入要查找的数：");
key = input.nextInt();

System.out.println("顺序查找，找到的位置为：" + (seqSearch(arr, key)));

System.out.println("二分查找，找到的位置为：" + binSearch(arr, key, 0, arr.size() - 1));
System.out.println("递归二分查找，找到的位置为：" + binSearchRecur(arr, key, 0, arr.size() - 1));

}

public static int seqSearch(List<Integer> arr, int key) {
for (int i = 0; i < arr.size(); i++) {
if (arr.get(i) == Integer.valueOf(key)) {
return i;
}
}
return -1;
}

public static int binSearch(List<Integer> arr, int key, int low, int high) {
int middle = (low + high) / 2;
while (low < high) {
if (arr.get(middle) < key) {
low = middle + 1;
} else if (arr.get(middle) > key) {
high = middle - 1;
} else {
return middle;
}
//每次缩小一半范围
middle = (low + high) / 2;
}
return -1;
}

/**
* 递归二分查找
* @param arr
* @param key
* @param low
* @param high
* @return
*/
public static int binSearchRecur(List<Integer> arr, int key, int low, int high) {

if (low > high)
return -1;
int middle = (low + high) / 2;
if (arr.get(middle) == key) {
return middle;
}
if (arr.get(middle) < key) {
return binSearchRecur(arr, key, middle + 1, high);
} else {
return binSearchRecur(arr, key, low, middle - 1);
}
}
}

# 分块查找

1.创建索引表。
2.在索引表内查找，在块内查找。

(分块查找索引表)平均查找长度=Log2（n/s+1）+s/2

(顺序查找索引表)平均查找长度=(S2+2S+n)/(2S)

①在表中插入或删除一个记录时，只要找到该记录所属的块，就在该块内进行插入和删除运算。
②因块内记录的存放是任意的，所以插入或删除比较容易，无须移动大量记录。
分块查找的主要代价是增加一个辅助数组的存储空间和将初始表分块排序的运算。

# 散列查找

[ 什么是散列表查找 ]

[ 散列技术的优缺点 ]

[ 散列函数构造方法 ]
1. 直接定址法：
2. 数字分析法：
3. 平方取中法：
4. 折叠法：
5. 除留余数法：
6. 随机数法：

[ 处理散列冲突的方法 ]
1. 开放地址法：
2. 再散列函数法：
3. 链地址法：
4. 公共溢出区法：

[ 散列表查找实现 ]

http://blog.chinaunix.net/uid-26981819-id-4462638.html 源码分析

[ 散列表查找性能分析 ]

# 二叉查找树查找

static class node{
int value;
node leftChild;
node rightChild;
}

public static node BSTSearch(node head,int key){
}else {
}
}

public static node BSTSearch(node head,int key){
}else{
}
break;
}
}
}

#### 二叉排序树中查找效率最高的是

2016-11-15 22:38:30

#### 查找中的算法----HASH查找,二分查找,堆查找,B树查找,字典树,海量查找

2014-06-06 20:18:09

#### 查找算法（二叉搜索树查找，二分查找，hash查找）

2016-07-12 12:58:16

#### 909422229__三种查找算法:顺序查找，二分法查找（折半查找），分块查找

2016-08-25 19:35:26

#### 算法-查找-线性表的查找（顺序查找，二分查找，分块查找）

2015-11-10 11:57:06

#### 查找算法（顺序查找、二分法查找、二叉树查找、hash查找）

2015-09-04 15:22:52

#### 查找算法系列之简单查找：顺序查找、二分查找、分块查找

2015-06-25 13:20:01

#### 树上的查找-二叉排序树

2014-08-24 20:08:27

#### 常用查找算法（顺序、折半、二叉树、哈希、分块）介绍

2016-03-16 16:35:55

#### 哈希查找

2017-11-03 19:44:14