文章目录
思维导图
1.线性查找
- 线性查找也叫顺序查找，这是最基本的一种查找方法，从给定的值中进行搜索，从一端开始逐一检查每个元素，直到找到所需元素的过程。
1.1 代码实现
/**
* 线性查找
* @author xiexu
* @create 2020-11-09 3:06 下午
*/
public class SeqSearch {
public static void main(String[] args) {
int[] arr = {1, 9, 11, -1, 34, 89};
int index = seqSearch(arr, 34);
if (index == -1) {
System.out.println("没有找到");
} else {
System.out.println("找到了下标在：" + index);
}
}
/**
* 此处实现的线性查找是找到一个满足条件的值,就返回
*
* @param arr
* @param value
* @return
*/
public static int seqSearch(int[] arr, int value) {
//线性查找是逐一比对，发现有相同值，就返回下标
for (int i = 0; i < arr.length; i++) {
if (arr[i] == value) {
return i;
}
}
return -1;
}
}
2.二分查找
思路分析
1. 首先确定该数组的中间的下标
mid = (left + right) / 2
2. 然后让需要查找的数 findVal 和 arr[mid] 比较
2.1 findVal > arr[mid], 说明你要查找的数在mid 的右边, 因此需要递归的向右查找。
2.2 findVal < arr[mid], 说明你要查找的数在mid 的左边, 因此需要递归的向左查找。
2.3 findVal == arr[mid], 说明找到，直接返回。
3. 什么时候我们需要结束递归?
3.1 找到就结束递归。
3.2 递归完整个数组，仍然没有找到findVal ，也需要结束递归 当 left > right 就需要退出。
2.1 代码实现
请对一个有序数组进行二分查找 {1,8, 10, 89, 1000, 1234} ，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示"没有这个数"。
/**
* 注意:使用二分查找的数组,必须是有序的
* @author xiexu
* @create 2020-11-09 3:51 下午
*/
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1, 8, 10, 89, 1000, 1234};
int search = binarySearch(arr,0,arr.length,10);
System.out.println("search = " + search);
}
//二分查找算法
/**
* @param arr 数组
* @param left 左边的索引
* @param right 右边的索引
* @param findVal 要查找的值
* @return 如果找到，就返回下标；否则返回-1
*/
public static int binarySearch(int[] arr, int left, int right, int findVal) {
//当left>right时，说明递归完整个数组，没有找到要查找的数
if (left > right) { //没有这个判断,会造成死递归！！！！
return -1;
}
int mid = (left + right) / 2;
int midVal = arr[mid];
if (findVal > midVal) { //向右递归
return binarySearch(arr, mid + 1, right, findVal);
} else if (findVal < midVal) { //向左递归
return binarySearch(arr, left, mid - 1, findVal);
}else {
return mid; //刚好在中间
}
}
}
对以上代码进行优化
{1,8, 10, 89, 1000, 1000, 1234} 当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000.
/**
* 注意:使用二分查找的数组,必须是有序的
* @author xiexu
* @create 2020-11-09 3:51 下午
*/
public class BinarySearch {
public static void main(String[] args) {
int arr[] = {1,8, 10, 89, 1000,1000, 1234};
List<Integer> res = binarySearch2(arr, 0, arr.length - 1, 1000);
System.out.println("res = " + res);
}
//{1,8, 10, 89, 1000, 1000，1234}
//当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000.
//思路分析:
//1.在找到mid索引值时,不要马上返回
//2.向mid索引值的左边扫描,将所有满足 1000的元素的下标，加入到集合ArrayList中
//3.向mid索引值的右边扫描,将所有满足 1000的元素的下标，加入到集合ArrayList中
//4.返回ArrayList集合
public static List binarySearch2(int[] arr, int left, int right, int findVal) {
//当left>right时，说明递归完整个数组，没有找到要查找的数
if (left > right) {
return new ArrayList();
}
int mid = (left + right) / 2;
int midVal = arr[mid];
if (findVal > midVal) { //向右递归
return binarySearch2(arr, mid + 1, right, findVal);
} else if (findVal < midVal) { //向左递归
return binarySearch2(arr, left, mid - 1, findVal);
}else {
ArrayList<Integer> list = new ArrayList<>();
//向mid索引值的左边扫描，将所有满足1000的元素的下标，加入到集合list中
int temp = mid - 1;
while (true) {
if(temp < 0 || arr[temp] != findVal) {
break;
}
//否则,就将temp放入集合
list.add(temp);
temp -= 1; //向左移动temp
}
list.add(mid);
//向mid索引值的右边扫描，将所有满足1000的元素的下标，加入到集合list中
temp = mid + 1;
while (true) {
if(temp > arr.length - 1 || arr[temp] != findVal) {
break;
}
//否则,就将temp放入集合
list.add(temp);
temp += 1; //向左移动temp
}
return list;
}
}
}
3.插值查找
- 插值查找算法类似于二分查找，不同的是插值查找每次从自适应
mid处开始查找。 - 将折半查找中的求mid 索引的公式 ,
low 表示左边索引left，high表示右边索引right，key 就是前面我们讲的findVal
- int mid =
low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]);插值索引
对应前面的代码公式：
int mid =left + ( right – left ) * ( findVal – arr[left] ) / ( arr[right] – arr[left] )
举例说明插值查找算法 1-100
具体思路:
数组 arr = [1, 2, 3, ......., 100]
假如我们需要查找的值 1
使用二分查找的话，我们需要多次递归，才能找到 1
使用插值查找算法:
int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
int mid = 0 + (99 - 0) * (1 - 1)/ (100 - 1) = 0 + 99 * 0 / 99 = 0
比如我们查找的值 100
int mid = 0 + (99 - 0) * (100 - 1) / (100 - 1) = 0 + 99 * 99 / 99 = 0 + 99 = 99
综上,插值查找算法 ==》 套公式计算即可
3.1 代码实现
/**
* 插值查找算法
*
* @author xiexu
* @create 2020-11-09 10:11 下午
*/
public class InsertValueSearch {
public static void main(String[] args) {
int arr[] = {1, 8, 10, 89, 1000, 1234};
int index = insertValueSearch(arr, 0, arr.length - 1, 1234);
System.out.println("index = " + index);
int index2 = binarySerch(arr, 0, arr.length - 1, 1234);
System.out.println("index2 = " + index2);
}
//二分查找
public static int binarySerch(int arr[], int left, int right, int findVal) {
System.out.println("二分查找被调用...");
//当left > right时,整个数组都没有
if (left > right) { //没有这个判断,会造成死递归！！！！
return -1;
}
int mid = (left + right) / 2;
int midVal = arr[mid];
if (findVal > midVal) { //向右递归
return binarySerch(arr, mid + 1, right, findVal);
} else if (findVal < midVal) { //向左递归
return binarySerch(arr, left, mid - 1, findVal);
} else {
return mid;
}
}
//插值查找算法
//说明：插值查找算法，也要求数组是有序的
/**
* @param arr 数组
* @param left 左边索引
* @param right 右边索引
* @param findVal 查找的值
* @return 如果找到，就返回对应的下标，如果没有找到，就直接返回-1
*/
public static int insertValueSearch(int[] arr, int left, int right, int findVal) {
System.out.println("插值查找被调用...");
//注意：findVal < arr[0] 和 findVal > arr[arr.length - 1] 是必须需要的
//否则我们得到的mid有可能越界
if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
return -1;
}
//求出mid，自适应写法
int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
int midVal = arr[mid];
if (findVal > midVal) { //说明应该向右递归
return insertValueSearch(arr, mid + 1, arr.length - 1, findVal);
} else if (findVal < midVal) {
return insertValueSearch(arr, 0, mid - 1, findVal);
} else {
return mid;
}
}
}
插值查找注意事项
- 对于数据量较大，关键字分布比较均匀的查找表来说，采用
插值查找，速度较快 关键字分布不均匀(跳跃性很大)的情况下，该方法不一定比折半查找要好
4.斐波那契查找
斐波那契(黄金分割法)查找基本介绍
- 黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意向不大的效果。
斐波那契数列{ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 发现斐波那契数列的两个相邻数 的比例，无限接近 黄金分割值0.618
斐波那契(黄金分割法)原理
斐波那契查找原理与前两种相似，仅仅改变了中间结点（mid）的位置，mid不再是中间或插值得到，而是位于黄金分割点附近，即mid=low+F[k-1]-1（F代表斐波那契数列、k代表斐波那契数列的下标），如下图所示:
对F(k-1)-1的理解
- 由斐波那契数列
F[k]=F[k-1]+F[k-2]的性质，可以得到（F[k]-1）=（F[k-1]-1）+（F[k-2]-1）+1。该式说明：只要顺序表的长度为F[k]-1，则可以将该表分成长度为F[k-1]-1和F[k-2]-1的两段，即如上图所示。从而中间位置为mid=low+F[k-1]-1。 - 类似的，每一子段也可以用相同的方式分割。da
- 但
数据的最大索引n不一定刚好等于F[k]-1，所以需要将原来的数据的最大索引n增加至F[k]-1。这里的k值只要能使得F[k]-1恰好大于或等于n即可，由以下代码得到，顺序表长度增加后，新增的位置（从n+1到F[k]-1位置），都赋为n位置的值即可。
while(n > fib(k) - 1){
k++;
}
4.1 代码实现
/**
* 斐波那契查找算法
* 斐波那契数列 {1,1,2,3,5,8,13,21,34...}
*
* @author xiexu
* @create 2020-11-10 10:01 上午
*/
public class FibSearch {
public static int maxSize = 20;
public static void main(String[] args) {
//斐波那契算法要求查找的数组必须是有序的
int arr[] = {1, 8, 10, 89, 1000, 1234};
System.out.println("index = " + fibSearch(arr, 1000));
}
// 因为后面需要使用公式 mid=low+F(k-1)-1,因此需要先获取到一个斐波那契数列
// 用非递归方法得到一个斐波那契数列
public static int[] fib() {
int f[] = new int[maxSize];
f[0] = 1;
f[1] = 1;
for (int i = 2; i < maxSize; i++) {
f[i] = f[i - 1] + f[i - 2];
}
return f;
}
/**
* 使用非递归的方式编写斐波那契查找算法
* @param a 数组
* @param key 需要查找的关键值
* @return
*/
public static int fibSearch(int[] a, int key) {
int low = 0; //数组最小数的索引
int high = a.length - 1; //数组最大数的索引
int k = 0; //斐波那契数列的下标
int mid = 0; //获取mid值
int f[] = fib(); //获取到斐波那契数列
//获取斐波那契数列分割值的下标
while (high > f[k] - 1) {
k++;
}
// 因为f[k]的值可能大于a数组的长度，因此我们需要使用Arrays类,构造一个新的数组,并指向temp[]
// 不足的部分会使用0填充
int[] temp = Arrays.copyOf(a, f[k]);
// 需要使用a数组最后的数填充 temp
// 举例:
// temp = { 1, 8, 10, 89, 1000, 1234, 0, 0 }
// => { 1, 8, 10, 89, 1000, 1234, 1234, 1234 }
for (int i = high + 1; i < temp.length; i++) {
temp[i] = a[high];
}
//利用循环查找key
while (low <= high) { //满足这个条件，就继续查找
mid = low + f[k - 1] - 1;
if (key < temp[mid]) { //继续向左边查找
high = mid - 1;
// 使用k--的原因
// 说明:
// 1.全部元素 = 前面的元素 + 后边元素
// 2.f[k]-1 = f[k-1] -1 + f[k-2] -1 + 1
// f[k] = f[k-1] + f[k-2]
// 因为前面有f[k-1]个元素，所以可以继续拆分 f[k-1] = f[k-2] + f[k-3]
// 即在 f[k-1] 的前面继续查找 k--
// 即下次循环 mid = low + f[k-1-1]-1
k--;
} else if (key > temp[mid]) { //继续向右边查找
low = mid + 1;
// 使用k -= 2 的原因
// 说明：
// 1.全部元素 = 前面的元素 + 后边元素
// 2.f[k] = f[k-1] + f[k-2]
// 3.因为后面有f[k-2]个元素，所以可以继续拆分 f[k-1] = f[k-3] + f[k-4]
// 4.即在f[k-2] 的前面继续查找 k -= 2
// 5.即下次循环 mid = low + f[k - 1 - 2] - 1
k -= 2;
} else { //找到
// 需要确定,返回的是哪个下标
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
}
5.哈希表
思维导图
5.1 哈希表基本介绍
- 散列表（Hash table，也叫哈希表），是根据关键码值
(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中的一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
哈希表结构
所以什么叫哈希表？
- 哈希表可以用来高效率解决
元素不可重复这个问题，其本质就是：数组+链表+红黑树(后面会写)。
5.2 哈希表的实现
先看一个实际需求，google公司的一个上机题:
有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址…),当输入该员工的id时,要求查找到该员工的 所有信息.
要求: 不使用数据库,尽量节省内存,速度越快越好 => 哈希表(散列)
要求:
1.不使用数据库,,速度越快越好 => 哈希表(散列).
2.添加时，保证按照id从低到高插入
[课后思考：如果id不是从低到高插入，但要求各条链表仍是从低到高，怎么解决?]
3.使用链表来实现哈希表,该链表不带表头[即:链表的第一个结点就存放雇员信息]
4.思路分析并画出示意图
思路图解
使用哈希表来管理雇员信息
5.3 代码实现
/**
* @author xiexu
* @create 2020-11-10 9:02 下午
*/
public class HashTabDemo {
public static void main(String[] args) {
//创建哈希表
HashTab hashTab = new HashTab(7);
//写一个简单的菜单
String key = "";
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("雇员管理系统:");
System.out.println("add : 添加雇员");
System.out.println("list: 显示雇员");
System.out.println("find: 查找雇员");
System.out.println("del : 删除雇员");
System.out.println("exit: 退出系统");
key = scanner.next();
switch (key) {
case "add":
System.out.print("输入id:");
int id = scanner.nextInt();
System.out.print("输入名字:");
String name = scanner.next();
//创建雇员
Emp emp = new Emp(id, name);
hashTab.add(emp);
break;
case "list":
hashTab.list();
break;
case "find":
System.out.print("请输入需要查找的id:");
id = scanner.nextInt();
hashTab.findEmpId(id);
break;
case "del":
System.out.print("请输入雇员的id:");
id = scanner.nextInt();
hashTab.delEmpId(id);
break;
case "exit":
scanner.close();
System.exit(0); //退出程序
default:
break;
}
}
}
}
//创建HashTab，用于管理多条链表
class HashTab {
private EmpLinkedList[] empLinkArray;
private int size; //表示有多少条链表
//构造器
public HashTab(int size) {
this.size = size;
//初始化empLinkArray
empLinkArray = new EmpLinkedList[size];
//注意：一定要分别初始化每个链表,很重要！！！！
for (int i = 0; i < size; i++) {
empLinkArray[i] = new EmpLinkedList();
}
}
//添加雇员
public void add(Emp emp) {
//根据雇员的id，得到该雇员应该添加到哪条链表
int empLinkNo = hashFun(emp.id);
//将emp添加到对应的链表中
empLinkArray[empLinkNo].add(emp);
}
//遍历所有的链表，遍历HashTab
public void list() {
for (int i = 0; i < size; i++) {
empLinkArray[i].list(i);
}
}
//编写一个散列函数，使用一个简单的取模运算
public int hashFun(int id) {
return id % size;
}
//根据输入的id查找雇员
public void findEmpId(int id) {
int empLinkNo = hashFun(id);
Emp emp = empLinkArray[empLinkNo].findEmpId(id);
if (emp != null) { //找到了
System.out.printf("在第%d条链表中找到,雇员 id = %d\n", (empLinkNo + 1), id);
} else {
System.out.println("在哈希表中,没有找到该雇员~");
}
}
//根据雇员的id从哈希表中删除雇员
public void delEmpId(int id) {
int index = hashFun(id);
empLinkArray[index].delEmp(id);
}
}
//表示一个雇员
class Emp {
public int id;
public String name;
public Emp next; //next默认为null
public Emp(int id, String name) {
this.id = id;
this.name = name;
}
}
//创建一个EmpLinkedList，表示链表
class EmpLinkedList {
//头指针，指向第一个Emp，因此这个链表的head是有效的，直接指向第一个Emp
private Emp head; //默认为null
//添加雇员到链表
//说明
//1.假设当添加雇员时，id是自增长的，即id是从小到大的
//因此可以将该雇员直接加入到本链表的最后即可
public void add(Emp emp) {
//如果是添加第一个雇员
if (head == null) {
head = emp;
return;
}
//如果不是第一个，则使用一个辅助指针，帮助定位
Emp curEmp = head;
while (true) {
if (curEmp.next == null) { //到达链表的最后
break;
}
curEmp = curEmp.next;
}
//退出时直接将emp加入链表
curEmp.next = emp;
}
//遍历链表的雇员信息
public void list(int no) {
if (head == null) { //说明该链表为空
System.out.println("第" + (no + 1) + "条链表为空");
return;
}
System.out.print("第" + (no + 1) + "条链表的信息为：");
Emp curEmp = head; //定义一个辅助指针
while (true) {
System.out.printf("=> id = %d name = %s\t", curEmp.id, curEmp.name);
if (curEmp.next == null) { //说明curEmp已经是链表最后的节点了
break;
}
curEmp = curEmp.next; //后移
}
System.out.println();
}
//根据id查找雇员
//如果找到就返回Emp,否则返回null
public Emp findEmpId(int id) {
//判断链表是否为空
if (head == null) {
System.out.println("链表为空");
return null;
}
//辅助指针
Emp curEmp = head;
while (true) {
if (curEmp.id == id) { //找到了
break;
}
//退出
if (curEmp.next == null) {
curEmp = null;
break;
}
curEmp = curEmp.next;
}
return curEmp;
}
//根据id删除雇员
public void delEmp(int id) {
//判断链表是否为空
if (head == null) {
System.out.println("链表为空");
}
//如果删除的是头结点
if (head.id == id) {
head = head.next; //让head的下一个元素当做head
return;
}
//如果删除的不是头结点
Emp temp = head; //定义一个辅助指针
while (true) {
if (temp.next != null) {
if (temp.next.id == id) {
temp.next = temp.next.next;
System.out.println("id为" + id + "的员工已经被删除");
return;
}
} else {
System.out.println("没有这个员工");
}
}
}
}
扫一扫
1062
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
