基本查找
基本查找是一种简洁的查找算法，其原理是从数据的一端开始，顺序扫描，依次将遍历到的结点与要查找的值相比较，若相等则表示查找成功；若遍历结束仍没有找到相同的，表示查找失败。
实现起来也比较简单：
public static boolean basicSearch(int[] arr, int number){
for (int i = 0; i < arr.length; i++) {
if(arr[i] == number){
return true;
}
}
return false;
}
}
这种方法面对存储结构为数组或者链表会较为合适，但在特定场景下可能会存在时间复杂度的问题；
二分查找
对于二分法查找元素，首先要保证元素必须是有序的，从小到大，或者从大到小都是可以的。
如果是无序的，也可以先进行排序（排序算法后面会说）；
但是会存在一个问题，当你进行排序之后，会改变原有数据的顺序，如果此时要求返回索要查找到的数字的索引，此时就会使得数字位置因为排序而打乱。
基本思想：用给定值先与中间结点比较。比较完之后有三种情况：
- 相等：说明找到了
- 要查找的数据比中间节点小：说明要查找的数字在中间节点左边
- 要查找的数据比中间节点大：说明要查找的数字在中间节点右边
以下是实现的代码
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;
}
}
}
}
分块查找
分块查找适用的场景比较少，但是大体上是将一组数据进行分块，先确定需要查找的数据位于哪一块，然后再对应的数据块内进行查找；
然而这样的数据需要有以下的特点才可以使用分块查找：
- 前一块的数据最大值要小于后一块的数据最小值；
- 分块的个数一般服从于总数居的长度开根号；
以下写了一个案例进行分块查找的说明：
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(21,0,5);
Block b2 = new Block(45,6,11);
Block b3 = new Block(73,12,17);
//定义数组用来管理三个块的对象（索引表）
Block[] blockArr = {b1,b2,b3};
//定义一个变量用来记录要查找的元素
int number = 37;
//调用方法
int index = getIndex(blockArr,arr,number);
//打印一下
System.out.println(index);
}
private static int getIndex(Block[] blockArr, int[] arr, int number) {
//调用findIndexBlock
int indexBlock = findIndexBlock(blockArr, number);
if(indexBlock == -1){
//表示number不在数组当中
return -1;
}
//获取这一块的起始索引和结束索引
int startIndex = blockArr[indexBlock].getStartIndex();
int endIndex = blockArr[indexBlock].getEndIndex();
//遍历
for (int i = startIndex; i <= endIndex; i++) {
if(arr[i] == number){
return i;
}
}
return -1;
}
//定义一个方法，用来确定number在哪一块当中
public static int findIndexBlock(Block[] blockArr,int number){ //100
for (int i = 0; i < blockArr.length; i++) {
if(number <= blockArr[i].getMax()){
return i;
}
}
return -1;
}
}
//创建Block对象
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;
}
public int getMax() {
return max;
}
public void setMax(int max) {
this.max = max;
}
public int getStartIndex() {
return startIndex;
}
public void setStartIndex(int startIndex) {
this.startIndex = startIndex;
}
public int getEndIndex() {
return endIndex;
}
public void setEndIndex(int endIndex) {
this.endIndex = endIndex;
}
public String toString() {
return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
}
}
插值查找
插值查找其实是对二分查找中的mid的值进行改进：
/(a[high]-a[low])*(high-low);
对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。代码只需要将二分查找的mid的计算方式换位==换成上述表达式即可；
斐波那契查找
public class FeiBoSearch {
public static int maxSize = 20;
public static void main(String[] args) {
int[] arr = {1, 8, 10, 89, 1000, 1234};
System.out.println(search(arr, 1234));
}
//生成斐波那契数列
public static int[] getFeiBo() {
int[] arr = new int[maxSize];
arr[0] = 1;
arr[1] = 1;
for (int i = 2; i < maxSize; i++) {
arr[i] = arr[i - 1] + arr[i - 2];
}
return arr;
}
public static int search(int[] arr, int key) {
int low = 0;
int high = arr.length - 1;
//表示斐波那契数分割数的下标值
int index = 0;
int mid = 0;
//调用斐波那契数列
int[] f = getFeiBo();
//获取斐波那契分割数值的下标
while (high > (f[index] - 1)) {
index++;
}
//因为f[k]值可能大于a的长度，因此需要使用Arrays工具类，构造一个新法数组，并指向temp[],不足的部分会使用0补齐
int[] temp = Arrays.copyOf(arr, f[index]);
//实际需要使用arr数组的最后一个数来填充不足的部分
for (int i = high + 1; i < temp.length; i++) {
temp[i] = arr[high];
}
//使用while循环处理，找到key值
while (low <= high) {
mid = low + f[index - 1] - 1;
if (key < temp[mid]) {//向数组的前面部分进行查找
high = mid - 1;
/*
对k--进行理解
1.全部元素=前面的元素+后面的元素
2.f[k]=k[k-1]+f[k-2]
因为前面有k-1个元素没所以可以继续分为f[k-1]=f[k-2]+f[k-3]
即在f[k-1]的前面继续查找k--
即下次循环,mid=f[k-1-1]-1
*/
index--;
} else if (key > temp[mid]) {//向数组的后面的部分进行查找
low = mid + 1;
index -= 2;
} else {//找到了
//需要确定返回的是哪个下标
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
}
然而其实只是在二分查找的基础上进行了优化，优化中间点mid的计算方式，一般不常用；
树表查找
利用二叉查找树左右分支值的特性，通过比较每一行的每个节点的父节点，查找最适合的范围
代码实现如下所示：
public class BST { //构建二叉排序树
public BSTNode root;
public BST() {
this.root = null;
}
public void insert(int data) {
if (this.root == null) {
root = new BSTNode();
root.key = data;
} else {
bSTInsert(this.root, data);
}
}
public void bSTInsert(BSTNode node, int key) {
if (node==null || node.key==key) {
return;
} else if (node.key > key) {
if (node.lchild == null) {
BSTNode temp = new BSTNode();
temp.key = key;
node.lchild = temp;
} else {
bSTInsert(node.lchild, key);
}
} else {
if (node.rchild==null) {
BSTNode temp = new BSTNode();
temp.key = key;
node.rchild = temp;
} else {
bSTInsert(node.rchild, key);
}
}
}
public void createBFS(int[] a) { // 创建二叉排序树
int i = 0;
while (i<a.length) {
this.insert(a[i]);
i++;
}
}
public void print() { //打印二叉排序树
if (this.root == null) {
System.out.println("树为空");
} else {
print(root);
}
}
public void print(BSTNode node) { //中序遍历二叉树
if (node == null) {
return;
} else {
print(node.lchild);
System.out.print(node.key + " ");
print(node.rchild);
}
}
/** 查找二叉排序树 */
public BSTNode BSTSearch(int key) {
if (this.root == null) {
return null;
} else {
if (this.root.key == key) {
return root;
} else {
return this.bSTSearch(root, key);
}
}
}
public BSTNode bSTSearch(BSTNode node, int key) {
if (node.key == key) {
return node;
} else if (node.key > key) {
if (node.lchild != null) {
return bSTSearch(node.lchild, key);
} else {
return null;
}
} else {
if (node.rchild!=null) {
return bSTSearch(node.rchild,key);
} else {
return null;
}
}
}
}
class BSTNode { // 二叉排序树节点类
public int key;
public BSTNode lchild;
public BSTNode rchild;
public BSTNode() {
this.lchild = null;
this.rchild = null;
}
}
基于二叉查找树进行优化，进而可以得到其他的树表查找算法，如平衡树、红黑树等高效算法。
不管是二叉查找树，还是平衡二叉树，还是红黑树，查找的性能都比较高
哈希查找
对于哈希查找实现查找的原理是将一组序列通过哈希变换（hash()）来得到在哈希表中的地址值，然后根据地址值相应的分配
到哈希表中，然后我们输入要查找的数据，将这个数据会进行相同的哈希变换得到地址值，通过这个地址值去找数据。
然而在经过所谓的哈希变换得到地址值这一步中，可能会存在不同的数据变换后的地址值相同，我们叫哈希冲突。所以在哈
希查找需要解决的一大问题就是如何把每个数据分配的地址值不同。
例如有的变换是把数值进行取余，那么31和63对1取余的结果都是8，所以造成了哈希冲突。有以下办法可以解决
- 线性探测法：首先按照序列顺序进行哈希变换，如果碰到地址值冲突的一组数据，那么就将此数据的地址值向后移，若后一位有数据，那么就继续向后移；若移动到哈希表的最后一位依旧有数据，那么就返回到哈希表第一位进行安排地址值。如果移动到null都没有找到这个数据，或者又重新移动到了起点，那么就说明要查找的数据不在此序列中。其实这种方法属于开放地址哈希。代码如下所示：
int hash_search(int* hashArr, int value) {
//hashArr是哈希表，此时已经将序列中的数据分配给哈希表了
//value是要查找的元素
int hashAdd = hash(value); //查找目标元素所在的索引
while (hashArr[hashAdd] != value) { // 如果索引位置不是目标元素，则发生了碰撞
//N为序列的长度
hashAdd = (hashAdd + 1) % N; // 根据线性探测法，从索引位置依次向后探测
//如果探测位置为空，或者重新回到了探测开始的位置（即探测了一圈），则查找失败
if (hashArr[hashAdd] == 0 || hashAdd == hash(value)) {
return -1;
}
}
//返回目标元素所在的数组下标
return hashAdd;
}
- 链地址法：用此方法来处理哈希冲突的原理是，如果有相同的地址值出现，那么在此位置创建一个链表，将这相同的数据进行存储，查找的时候获取到对应槽的链表，这个链表里的数据特点是经过哈希变换后都是相同的值，直接用数值去找链表里的数值，此时而不用哈希转换后的地址值去寻找。
public Integer search(String key) {
int index = hashFunction(key); // 计算哈希值
LinkedList<Node> list = table[index]; // 获取对应槽的链表
for (Node node : list) {
if (node.key.equals(key)) {
return node.value; // 找到匹配的键，返回对应的值
}
}
return null; // 没有找到匹配的键，返回null
}
如有问题可私信我修改；
2018
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
