常用查找算法的总结

数据结构中查找的知识点主要有以下三点

1、静态查找

  1.1 顺序查找

  1.2 有序表

      1.2.1 二分查找

      1.2.2 插值查找

2、动态查找

  2.1 二叉排序树

  2.2 平衡二叉树

  2.3 B-和B+树

3、哈希查找

  3.1 常用哈希函数

  3.2 解决冲突的办法

1.2.1.1  非递归实现

实现思路:

1、low=0,high=len-1;

2、mid=(low+high)/2;

3、中间值小于目标值,high=mid-1

4、中间值大于目标值,low=mid+1

5、重复

      public static int binarySearch(int[] data,int dest)
      {
          int high=data.length-1,low=0;
          int mid=0;//中间值
          int index=-1;//位置
          while(low<=high)
          {
              mid=(high+low)/2;
              if(dest>data[mid]) low=mid+1;
              else if(dest<data[mid]) high=mid-1;
              else {index=mid;break;}
          }
          return index;
      }

1.2.1.2 递归实现

实现思路:

将high,low作为参数传入即可

      public static int binarySearch(int[] data,int dest,int high,int low)
      {
          int mid=0;
          if(low<=high)
          {
              mid=(high+low)/2;
              if(dest>data[mid]) return binarySearch(data, dest, high, mid+1);
              else if(dest<data[mid]) return binarySearch(data, dest, mid-1, low);
              else {return mid;}
          }
          else
              return -1;
      }

 1.2.2 插值查找

  对二分查找的改进

  mid=low+(dest-data[low])/(data[high]-data[low])*(high-low);

      public static int binarySearch(int[] data,int dest,int high,int low)
      {
          int mid=0;
          if(low<=high)
          {
              mid=low+(dest-data[low])/(data[high]-data[low])*(high-low);
              if(dest>data[mid]) return binarySearch(data, dest, high, mid+1);
              else if(dest<data[mid]) return binarySearch(data, dest, mid-1, low);
              else {return mid;}
          }
          else
              return -1;
      }
时间: 2024-10-09 02:28:16

常用查找算法的总结的相关文章

c++STL之常用查找算法

引入#include<algorithm> 算法简介: find:查找元素 find_if:按条件查找 adjacent_find:查找相邻房重复的元素 binary_search:二分查找 count:统计元素个数 count_if:按条件统计元素个数 1.find #include<iostream> using namespace std; #include <vector> #include <algorithm> #include <stri

常用查找算法

原文出处:http://www.cnblogs.com/yw09041432/p/5908444.html 1.顺序查找 2.二分查找 3.差值查找 4.肥婆那楔查找 5.树表查找 6.分块查找 7.哈希查找 查找:根据给定的某个值,在查找表中确定一个其关键字等于给定值得数据元素(或记录). 查找算法分类: 1.静态查找和动态查找 动态查找指查找表中有删除和插入操作的表. 2.无序查找和有序查找 无序查找:被查找数列有序无序均可 有序查找:被查找数列必须有序 1.顺序查找 基本思想:顺序查找也称

【Java_Base】常用查找算法:顺序查找、二分查找

顺序查找 从第一个元素开始顺序比较查找. 二分查找 二分查找前提条件: 已排序的数组中查找 二分查找的基本思想是: 首先确定该查找区间的中间点位置: int mid = (low+upper) / 2; 然后将待查找的值与中间点位置的值比较: 若相等,则查找成功并返回此位置. 若中间点位置值大于待查值,则新的查找区间是中间点位置的左边区域. 若中间点位置值小于待查值,则新的查找区间是中间点位置的右边区域. 下一次查找是针对新的查找区间进行的. 1 public class Search{ 2 p

常用查找算法总结

1. 二分查找 //递归版 int binarySearch(const int arr[], int low, int high, int val) { if (low <= high) { int mid = low + (high - low) / 2; // Do not use (low + high) / 2 which might encounter overflow issue if (val < arr[mid]) return binarySearch(arr, low,

STL常用查找算法介绍

adjacent_find() 在iterator对标识元素范围内,查找一对相邻重复元素,找到则返回指向这对元素的第一个元素的迭代器.否则返回past-the-end. #include <iostream> #include <cstdio> #include <algorithm> #include <vector> using namespace std; void play_adjacent_find() { vector<int> v1

常用查找算法Python实现

二分法查找(递归): def binarySearch(arr, min, max, key): mid = int((max + min)/2) if key < arr[mid]: return binarySearch(arr, min, mid-1, key) elif key > arr[mid]: return binarySearch(arr, mid+1, max, key) elif key == arr[mid]: print("找到{0}了!是第{1}个数字!&

Java常用排序算法+程序员必须掌握的8大排序算法+二分法查找法

Java 常用排序算法/程序员必须掌握的 8大排序算法 本文由网络资料整理转载而来,如有问题,欢迎指正! 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空间最多:归并排序 所需辅助空间最少:堆排序 平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序. 先来看看 8种排序之间的关系: 1.直接插入排序 (1)基本思想:在要排序的一组数中,假设前面(n-1)[n>=2]

Java中常用的查找算法——顺序查找和二分查找

Java中常用的查找算法——顺序查找和二分查找 一.顺序查找: a) 原理:顺序查找就是按顺序从头到尾依次往下查找,找到数据,则提前结束查找,找不到便一直查找下去,直到数据最后一位. b) 图例说明: 原始数据:int[] a={4,6,2,8,1,9,0,3}; 要查找数字:8 代码演示: import java.util.Scanner; /* * 顺序查找 */ public class SequelSearch { public static void main(String[] arg

常用的排序、查找算法的时间复杂度和空间复杂度

常用的排序算法的时间复杂度和空间复杂度 排序法 最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 O(n2) O(n2) 稳定 O(1) 插入排序 O(n2) O(n2) 稳定 O(1) 选择排序 O(n2) O(n2) 稳定 O(1) 二叉树排序 O(n2) O(n*log2n) 不一顶 O(n) 快速排序 O(n2) O(n*log2n) 不稳定 O(log2n)~O(n) 堆排序 O(n*log2n) O(n*log2n) 不稳定 O(1) 希尔排序 O O 不稳定 O(1) 查