十、查找算法（Map的实现以及对比）

最新推荐文章于 2024-07-05 13:20:49 发布
最新推荐文章于 2024-07-05 13:20:49 发布
阅读量3.7k 收藏 4
点赞数
分类专栏： java算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guanhang89/article/details/50909649
版权

查找

这里使用符号表这个词来描述一张抽象的表格，我们会将信息存储在其中（值），然后按照指定的键来搜索并获取这些信息。符号表有时也被称为字典或者索引(说白了就是Map)

符号表

这里写图片描述

部分API

这里写图片描述

实现的注意事项：
每个键只对应着一个值；
当插入键值重复时，覆盖旧值；
键不能为空；值不能为空（这条规则可以拿来删除元素，put(key,null)）
删除：分为延时删除(如上面的put(key, null))和及时删除（delete()）

有序符号表的实现(有序的API会多一点，比如找最大、最小)

按照value排序的表(内部直接使用了TreeMap ，因为标准库的TreeMap是基于红黑树的，性能很好)，后面将会讨论怎么一步一步地选择优化到这个ST版本。

public class ST<Key extends Comparable<Key>, Value> implements Iterable<Key> {

    private TreeMap<Key, Value> st;
    public ST() {
        st = new TreeMap<Key, Value>();
    }

    public Value get(Key key) {
        if (key == null) throw new NullPointerException("called get() with null key");
        return st.get(key);
    }

    public void put(Key key, Value val) {
        if (key == null) throw new NullPointerException("called put() with null key");
        if (val == null) st.remove(key);
        else             st.put(key, val);
    }

    public void delete(Key key) {
        if (key == null) throw new NullPointerException("called delete() with null key");
        st.remove(key);
    }

    public boolean contains(Key key) {
        if (key == null) throw new NullPointerException("called contains() with null key");
        return st.containsKey(key);
    }
    public int size() {
        return st.size();
    }

    public boolean isEmpty() {
        return size() == 0;
    }
    public Iterable<Key> keys() {
        return st.keySet();
    }
    public Iterator<Key> iterator() {
        return st.keySet().iterator();
    }
    public Key min() {
        if (isEmpty()) throw new NoSuchElementException("called min() with empty symbol table");
        return st.firstKey();
    }
    public Key max() {
        if (isEmpty()) throw new NoSuchElementException("called max() with empty symbol table");
        return st.lastKey();
    }
    public Key ceiling(Key key) {
        if (key == null) throw new NullPointerException("called ceiling() with null key");
        Key k = st.ceilingKey(key);
        if (k == null) throw new NoSuchElementException("all keys are less than " + key);
        return k;
    }
    public Key floor(Key key) {
        if (key == null) throw new NullPointerException("called floor() with null key");
        Key k = st.floorKey(key);
        if (k == null) throw new NoSuchElementException("all keys are greater than " + key);
        return k;
    }
    public static void main(String[] args) {
        ST<String, Integer> st = new ST<String, Integer>();
        for (int i = 0; !StdIn.isEmpty(); i++) {
            String key = StdIn.readString();
            st.put(key, i);
        }
        for (String s : st.keys())
            StdOut.println(s + " " + st.get(s));
    }
}

应用

统计某个文件（英文小说）的单词（满足一定长度）出现的频率，输出频率最高的（一个），也是后面其他实现的一个标准评价试验：

public class FrequencyCounter {

    // Do not instantiate.
    private FrequencyCounter() { }
    public static void main(String[] args) {
        int distinct = 0, words = 0;
        int minlen = Integer.parseInt(args[0]);
        ST<String, Integer> st = new ST<String, Integer>();

        // compute frequency counts
        while (!StdIn.isEmpty()) {
            String key = StdIn.readString();
            if (key.length() < minlen) continue;
            words++;
            if (st.contains(key)) {
                st.put(key, st.get(key) + 1);
            }
            else {
                st.put(key, 1);
                distinct++;
            }
        }
        // find a key with the highest frequency count
        String max = "";
        st.put(max, 0);
        for (String word : st.keys()) {
            if (st.get(word) > st.get(max))
                max = word;
        }
        StdOut.println(max + " " + st.get(max));
        StdOut.println("distinct = " + distinct);
        StdOut.println("words    = " + words);
    }
}

基于无序链表中的顺序查找实现

用链表实现符号表，下图是使用案例的轨迹：
这里写图片描述
代码（注意理解删除键那里的写法)：

public class SequentialSearchST<Key, Value> {
    private int N;           // number of key-value pairs
    private Node first;      // the linked list of key-value pairs

    // a helper linked list data type
    private class Node {
        private Key key;
        private Value val;
        private Node next;

        public Node(Key key, Value val, Node next)  {
            this.key  = key;
            this.val  = val;
            this.next = next;
        }
    }
    public SequentialSearchST() {
    }
    public int size() {
        return N;
    }
    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean contains(Key key) {
        if (key == null) throw new NullPointerException("argument to contains() is null");
        return get(key) != null;
    }
    public Value get(Key key) {
        if (key == null) throw new NullPointerException("argument to get() is null"); 
        for (Node x = first; x != null; x = x.next) {
            if (key.equals(x.key))
                return x.val;
        }
        return null;
    }
    public void put(Key key, Value val) {
        if (key == null) throw new NullPointerException("first argument to put() is null"); 
        if (val == null) {
            delete(key);
            return;
        }

        for (Node x = first; x != null; x = x.next) {
            if (key.equals(x.key)) {
                x.val = val;
                return;
            }
        }
        first = new Node(key, val, first);
        N++;
    }
    public void delete(Key key) {
        if (key == null) throw new NullPointerException("argument to delete() is null"); 
        first = delete(first, key);
    }
    //递归调用，删除那个键
    private Node delete(Node x, Key key) {
        if (x == null) return null;
        if (key.equals(x.key)) {
            N--;
            return x.next;
        }
        x.next = delete(x.next, key);
        return x;
    }
    public Iterable<Key> keys()  {
        Queue<Key> queue = new Queue<Key>();
        for (Node x = first; x != null; x = x.next)
            queue.enqueue(x.key);
        return queue;
    }
    public static void main(String[] args) {
        SequentialSearchST<String, Integer> st = new SequentialSearchST<String, Integer>();
        for (int i = 0; !StdIn.isEmpty(); i++) {
            String key = StdIn.readString();
            st.put(key, i);
        }
        for (String s : st.keys())
            StdOut.println(s + " " + st.get(s));
    }
}

这里写图片描述
命中：成功的查找，未命中：失败的查找
因此：基于链表的实现以及顺序查找是非常低效的，无法满足处理庞大输入问题的需求

基于有序数组中的二分查找实现

键和值分别用一个数组来保存（put、delete的时候要移动数组所以消耗大）
注意floor和ceiling的实现

public class BinarySearchST<Key extends Comparable<Key>, Value> {
    private static final int INIT_CAPACITY = 2;
    private Key[] keys;
    private Value[] vals;
    private int N = 0;
    public BinarySearchST() {
        this(INIT_CAPACITY);
    }
    public BinarySearchST(int capacity) { 
        keys = (Key[]) new Comparable[capacity]; 
        vals = (Value[]) new Object[capacity]; 
    }   

    // resize the underlying arrays
    private void resize(int capacity) {
        assert capacity >= N;
        Key[]   tempk = (Key[])   new Comparable[capacity];
        Value[] tempv = (Value[]) new Object[capacity];
        for (int i = 0; i < N; i++) {
            tempk[i] = keys[i];
            tempv[i] = vals[i];
        }
        vals = tempv;
        keys = tempk;
    }
    public int size() {
        return N;
    }
    public boolean isEmpty() {
        return size() == 0;
    }
    public boolean contains(Key key) {
        if (key == null) throw new NullPointerException("argument to contains() is null");
        return get(key) != null;
    }
    public Value get(Key key) {
        if (key == null) throw new NullPointerException("argument to get() is null"); 
        if (isEmpty()) return null;
        int i = rank(key); 
        if (i < N && keys[i].compareTo(key) == 0) return vals[i];
        return null;
    } 
    //得到严格比key小的键个数
    public int rank(Key key) {
        if (key == null) throw new NullPointerException("argument to rank() is null"); 

        int lo = 0, hi = N-1; 
        while (lo <= hi) { 
            int mid = lo + (hi - lo) / 2; 
            int cmp = key.compareTo(keys[mid]);
            if      (cmp < 0) hi = mid - 1; 
            else if (cmp > 0) lo = mid + 1; 
            else return mid; 
        } 
        return lo;
    } 
    public void put(Key key, Value val)  {
        if (key == null) throw new NullPointerException("first argument to put() is null"); 

        if (val == null) {
            delete(key);
            return;
        }
        int i = rank(key);
        // key is already in table
        if (i < N && keys[i].compareTo(key) == 0) {
            vals[i] = val;
            return;
        }

        // insert new key-value pair
        if (N == keys.length) resize(2*keys.length);

        for (int j = N; j > i; j--)  {
            keys[j] = keys[j-1];
            vals[j] = vals[j-1];
        }
        keys[i] = key;
        vals[i] = val;
        N++;

        assert check();
    } 
    public void delete(Key key) {
        if (key == null) throw new NullPointerException("argument to delete() is null"); 
        if (isEmpty()) return;

        // compute rank
        int i = rank(key);

        // key not in table
        if (i == N || keys[i].compareTo(key) != 0) {
            return;
        }
        for (int j = i; j < N-1; j++)  {
            keys[j] = keys[j+1];
            vals[j] = vals[j+1];
        }
        N--;
        keys[N] = null;  // to avoid loitering
        vals[N] = null;

        // resize if 1/4 full
        if (N > 0 && N == keys.length/4) resize(keys.length/2);

        assert check();
    } 
    public void deleteMin() {
        if (isEmpty()) throw new NoSuchElementException("Symbol table underflow error");
        delete(min());
    }
    public void deleteMax() {
        if (isEmpty()) throw new NoSuchElementException("Symbol table underflow error");
        delete(max());
    }
    public Key min() {
        if (isEmpty()) return null;
        return keys[0]; 
    }
    public Key max() {
        if (isEmpty()) return null;
        return keys[N-1];
    }
    public Key select(int k) {
        if (k < 0 || k >= N) return null;
        return keys[k];
    }
    public Key floor(Key key) {
        if (key == null) throw new NullPointerException("argument to floor() is null"); 
        int i = rank(key);
        if (i < N && key.compareTo(keys[i]) == 0) return keys[i];
        if (i == 0) return null;
        else return keys[i-1];
    }
    public Key ceiling(Key key) {
        if (key == null) throw new NullPointerException("argument to ceiling() is null"); 
        int i = rank(key);
        if (i == N) return null; 
        else return keys[i];
    }
    public int size(Key lo, Key hi) {
        if (lo == null) throw new NullPointerException("first argument to size() is null"); 
        if (hi == null) throw new NullPointerException("second argument to size() is null"); 

        if (lo.compareTo(hi) > 0) return 0;
        if (contains(hi)) return rank(hi) - rank(lo) + 1;
        else              return rank(hi) - rank(lo);
    }
    public Iterable<Key> keys() {
        return keys(min(), max());
    }
    public Iterable<Key> keys(Key lo, Key hi) {
        if (lo == null) throw new NullPointerException("first argument to size() is null"); 
        if (hi == null) throw new NullPointerException("second argument to size() is null"); 

        Queue<Key> queue = new Queue<Key>(); 
        // if (lo == null && hi == null) return queue;
        if (lo == null) throw new NullPointerException("lo is null in keys()");
        if (hi == null) throw new NullPointerException("hi is null in keys()");
        if (lo.compareTo(hi) > 0) return queue;
        for (int i = rank(lo); i < rank(hi); i++) 
            queue.enqueue(keys[i]);
        if (contains(hi)) queue.enqueue(keys[rank(hi)]);
        return queue; 
    }
    private boolean check() {
        return isSorted() && rankCheck();
    }
    // are the items in the array in ascending order?
    private boolean isSorted() {
        for (int i = 1; i < size(); i++)
            if (keys[i].compareTo(keys[i-1]) < 0) return false;
        return true;
    }
    // check that rank(select(i)) = i
    private boolean rankCheck() {
        for (int i = 0; i < size(); i++)
            if (i != rank(select(i))) return false;
        for (int i = 0; i < size(); i++)
            if (keys[i].compareTo(select(rank(keys[i]))) != 0) return false;
        return true;
    }
    public static void main(String[] args) { 
        BinarySearchST<String, Integer> st = new BinarySearchST<String, Integer>();
        for (int i = 0; !StdIn.isEmpty(); i++) {
            String key = StdIn.readString();
            st.put(key, i);
        }
        for (String s : st.keys())
            StdOut.println(s + " " + st.get(s));
    }
}

这里写图片描述

但是： BinarysearchST仍然无法处理大型的FrequencyCounter的程序处理大型问题。因为它无法改变以下事实：在键是随机排列的情况下，构造一个基于有序数组的符号表所需要的访问数组的次数是数组长度的平方级别（构建符号表的代价太大）。
这里写图片描述
这里写图片描述

核心问题以及各种Map实现方法优缺点

一般情况下二分查找都比顺序查找快得多，它也是众多实际应用程序的最佳选择。但是二分查找不适合查找和输入时混合进行的以及符号表太大的情况。
下图对于二分查找是数组的访问次数，其他则是比较次数
这里写图片描述
核心的问题是在于我们是否能找到同时保证查找和插入操作都是对数级别的算法和数据结构（也就是二叉查找树，后面将会讨论）。
先给出预览：
这里写图片描述

guanhang89
关注
专栏目录
mysql中的查找算法_7种查找算法解析
weixin_35809867的博客
01-26 3398
http://blog.csdn.net/chinabhlt/article/details/47420391查找成功时的平均查找长度为：(假设每个数据元素的概率相等) ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;当查找不成功时，需要n+1次比较，时间复杂度为O(n);所以，顺序查找的时间复杂度为O(n)。C++实现源码：//顺序查找int SequenceSearch(...
常见的查找算法
machine_Heaven的博客
02-06 604
本文简单介绍一下7中查找算法，首先查找就是根据给定的值，在查找表中找到它的位置。 查找算法的分类： 静态查找和动态查找（都是针对查找表而言的。动态表示查找表中有增删操作） 无序查找和有序查找（有序查找要求必须为有序数列，无序则不要求） 平均查找长度（ASL）：需要和目标关键字进行比较的次数 对于含有n个数据元素的查找表，查找成功的平均查找长度为：ASL = Pi*Ci的和。 　　Pi：查找表中...
Java Map 遍历实例与效率比较
04-12
主要提供java中的map的遍历实例及效率比较
Java中Map相关的快速查找算法与唯一性探讨
linglingbaby的专栏
10-10 1975
在对《Set和hashCode()》的一篇原创文章写完后，由于对自己的一些论断产生了模糊和怀疑，因此又对Set进行了一些研究，形成本篇。     在Set的使用场景中，我们不外乎看中了她存储数据的唯一性，即不能存储重复值，这在某些应用场合下是很必要的一个特性。那么从更深一层来考
MAPF、多智能体、神经控制微分方程、交通状态估计
最新发布
weixin_45720999的博客
07-05 940
定义：MAPF是一类寻找多个智能体从起始位置到目标位置且无冲突的最优路径集合的问题。复杂性：随着智能体数量的增加，问题的状态空间会指数增长，因此MAPF已被证明是NP-hard问题。MAPF是一个重要的研究领域，涉及多个学科的交叉融合。随着人工智能和自动化技术的不断发展，MAPF将在更多领域得到应用和发展。通过不断优化算法和技术手段，MAPF将能够解决更复杂、更实际的问题，为人类的生产和生活带来更多便利和效益。
七种查找算法比较
weixin_45154016的博客
08-23 1239
七种查找算法 原文：https://blog.csdn.net/weixin_39241397/article/details/79344179 顺序查找 二分查找 插值查找 斐波那契查找 树表查找 分块查找 哈希查找 1.顺序查找 比较无脑，遍历所有内容查找 2.二分查找 3.插值查找（k分查找） 4.斐波那契查找（0.618分查找） 实际是一类查找方法，针对有序静态数据的查找 ...
算法——几种查找算法的比较和应用
weixin_34192732的博客
03-08 1627
2019独角兽企业重金招聘Python工程师标准>>> ...
几种常见的查找算法之比较
fyqcdbdx的专栏
09-24 1238
注意：查找没有无排序的情况下“折半或斐波那契”快速查找的！ 一、静态查找表： 1. 顺序查找，平均查找长度为：(n+1)/2 2. 有序表的查找之折半查找：前提必须是有序表，性能只有在均匀分布的时候才是最优的。 平均查找长度：log2(n+1)-1 当有概率涉及的查找中
Java中Map相关的快速查找算法与性探讨
01-20
假设存储在Set中的数据有很多条，很普通的一个实现是每放入Set一个值value1，便提取Set中已有的多条数据跟该value1值进行对比，若相同，则不允许放入，反之则放入。运气好的话，迭代到几个元素之后便能够判断该值...
东南大学操作系统实验——实现LRU算法及其近似算法
06-30
实验的目的是让学生掌握LRU算法的原理，通过实际编程实现加深理解，并对比不同实现的复杂度和难度。时间复杂度方面，LRU算法通常表现为O(1)，因为查找、插入和删除操作都在平均情况下具有常数时间复杂度。空间复杂度...
数据结构算法实现严蔚敏教材
04-13
这个资料包中的实现可以帮助学习者巩固所学，通过对比和优化不同实现，深化对数据结构和算法本质的理解。同时，与他人交流和分享这些实现，可以促进知识的共享和共同进步。 总之，严蔚敏《数据结构》教材的C++实现...
MAP译码算法的研究
02-13
map算法MAP算法在Turbo码译码中的实现及性能在数域中，串行级联的MAP算法是用于获得高性能的Turbo码译码器。一般情况下，解码器通过可编程门序列和EPROMs实现从4到512的任何状态码，其码率达到1/3至1/7（通过删余构造高码率）且交织长度为65536。解码的七个阶段是并行处理的。对于码率为1/3和1/7的16状态码且交织长度为65536比特且操作速率高达356kbit/s的条件下，编解码器的Eb/N0分别为0.32dB和-0.30dB，得到的误码率为10-5。同时，在BER下降到10-7时，Eb/N0也获得了小幅度的增大。随着Turbo码解码器同步技术的实现，提出了一种高效连续的MAP译码算法。
算法1.常见查找算法以及数据结构比较
yuluoxuanyuan1992的博客
09-17 666
最近一直在复习，查找算法作为最常用的算法，作为算法系列第一部分总结一下，一来作为笔记，二来可以与大家一起分享，共同学习，共同进步，转载请注明出处，谢谢。 1. 顺序查找 原理 顺序查找，按照字面意思，就是按照排列顺序，依次将查找关键词key与元数据每一项进行对比，如果找到就结束。 适用范围 所有数据，但是对于过大的数据，不太实用，时间复杂度较高 时间复杂度、空间复杂度分析 时间复杂度O（n
查找算法 哈希map的使用
qq_44886213的博客
04-11 1145
1.查找类问题 我们首先会想到，顺序查找，复杂度为O(n),但是如果让你查找m数十万次，复杂度变为O(mn)可能会突破时间限制。 比如说这个题 #include<bits/stdc++.h> using namespace std; int main(){ int mark[200001]={0}; //这样全赋值成0了？ int a,b; while(1){ scanf("%d%d",&a,&b); if(a+b==0) break; for(int i
map,二分查找,状态压缩,暴力(假硬币)
aaaghyaa的博客
05-11 791
c++ map,二分查找,状态压缩,暴力(假硬币) 1.map 一个键值对应一个值,值的初始为零 #include <bits/stdc++.h> using namespace std; int main() { map<int, int> a; //键值为 int ,值也为 int 的一个 map a[4]=5; //键值 4 的值 为 5 //遍历 for(auto i : a){ cout <<
java List Map数据对比 找出相同和不同的内容
热门推荐
java hadoop 专题
06-02 1万+
最近在搞一个，数据对比功能，但是需要得到新数据和数据库的数据，多出来的数据和缺少的内容 原先搞出来的是 弄了两个List集合进行匹配代码就不贴了，说一下思路把 List list1=new ArrayList();//新数据 List list2=new ArrayList();//数据库数据 GongGl //公共类 如果list1>list2则说明有新数据，然后拿着list1
数组的二分查找算法的原理、代码实现和注意事项
YesPlus的博客
03-11 227
1、原理图解 2、代码实现 public class Demo_Array { /** * * A:案例演示 * 数组高级二分查找代码 * B:注意事项 * 如果数组无序，就不能使用二分查找。 * 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。 */ public static void main(String[] args) {...
查找算法的实现
weixin_33712987的博客
03-22 67
1.顺序查找算法publicstaticintsequenceSearch(Object[]a,Objectx,intn) { a[n]=x; inti; for(i=0;;i++) if(a[i].equals(x))break; if(i<n)returni; elsereturn-1;...
对比两个map生成差异记录
看写写
02-15 5090
使用场景 对比本地数据和第三方数据的差异，差异分为三种：修改、删除、添加， 其中添加参数差异对比把参数互换即可得到删除差异。 其中用到的针对数字对比的函数在下面的链接中。 /*** 数据差异对比， 修改前项，修改后 */ public static final String DIFF_BEFORRE_SQL = "before"; public static final String...
31、map与unordered_map对比
03-28
map和unordered_map都是STL中的容器，用于存储键值对，但它们在底层实现和使用上有很大的不同。 1. 底层实现：map底层实现采用红黑树，因此它的元素是按照键值有序排列的；而unordered_map底层实现采用哈希表，因此它的元素是无序的。 2. 查找效率：由于map是按照键值有序排列的，因此在查找时可以使用二分查找等优化算法，因此查找效率较高，时间复杂度为O(logn)；而unordered_map是无序的，查找时需要遍历哈希桶中的元素，时间复杂度为O(1)。 3. 内存占用：由于map底层实现采用红黑树，需要额外存储指针等信息，因此内存占用较大；而unordered_map底层实现采用哈希表，不需要额外的指针信息，因此内存占用较小。 4. 插入、删除效率：由于map底层实现采用红黑树，插入、删除元素时需要执行平衡操作，因此效率较低，时间复杂度为O(logn)；而unordered_map底层实现采用哈希表，插入、删除元素时只需要进行哈希计算和移动指针等操作，因此效率较高，时间复杂度为O(1)。 5. 迭代器稳定性：由于map底层实现采用红黑树，因此在插入、删除元素时，迭代器不会失效；而unordered_map底层实现采用哈希表，可能会因为扩容等原因导致迭代器失效。 综上所述，map适用于需要按照键值有序排列的场景，而unordered_map适用于无序场景下需要高效查找、插入、删除元素的场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值