字符串的查找以及查重方法总结

已于 2024-07-09 21:50:59 修改
阅读量5.8k 收藏 16
点赞数 4
分类专栏： Java基础学习笔记 文章标签： java 开发语言
于 2019-05-30 17:16:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44187963/article/details/90676295
版权

掌握要求：

1、字符串查找的朴素算法
2、字符串查找的KMP算法
3、哈希表
4、字典树

1、字符串的查找之朴素算法

朴素算法思想很简单，就是将待查找字符串t在被查找的字符串s中一一对比，如果遇到相同字符就将t和s同时往后挪，再依次比较；如果将t子串一直比较完了都与s中对应的连续位置元素相等的话，则就成功找到了字串的位置，但若t子串未比较完就与s中元素不相同，则将t返回到第一个元素，而s返回到刚与t相同的第一个元素的下一个位置，再重复上面的步骤依次比较。

eg: 在原始字符串s中，寻找字符串t，如果找到返回t在s中首字母下标，否则返回-1
代码实现如下：

public static int find01(String s,String t){
    int i = 0;
    int j = 0;
    int k = 0;
    for(;i < s.length();i++){
        k = i;
        for(;j < t.length();j++){
            if(s.charAt(k) == t.charAt(j)){
                k++;
            }else{
                break;
            }
        }

        if(j == t.length()){
            return i;
        }
    }
    return -1;
}

还有另外一种好看的写法，同样是朴素算法，代码如下：

private static int find(String s, String t) {
     int i = 0;
     int j = 0;
     while(i < s.length() && j < t.length()){
         if(s.charAt(i) == t.charAt(j)) {
             i++;
             j++;
         }else{
             i = i-j+1;
             j = 0;
         }
         if(j == t.length()){
             return i-j;
         }
     }
     return -1;
}

但是吧，朴素算法的查找效率明显不高@_@

2、字符串的查找之kmp算法

kmp算法主要是对于朴素算法的优化，使得字符串查找更高效，kmp算法的原理：
查找过程大致与朴素算法相同，但区别在于在查找过程中在字符串s中每个元素只过一遍，不会对任意的某个元素反复判断两次。最核心的操作在于判断子串t中最长的公共前缀，过程如图：
代码实现如下：

private static int kmp(String s, String t) {
    int i = 0;
    int j = 0;
    int[] next = getNext(t);
    while(i < s.length() && j < t.length()) {
        if (j == -1 || s.charAt(i) == t.charAt(j)) {
            i++;
            j++;
        } else {
            j = next[j];
        }
    }
    if(j == t.length()){
        return i-j;
    }else{
        return -1;
    }
}

private static int[] getNext(String t) {
    int[] next = new int[t.length()];
    int k = -1;
    int j = 0;
    next[0] = -1;
    //检测每一个字符之前的字符串，计算他们的前后缀最大长度
    //然后把长度记录在当前的next数组位置当中
    while(j < t.length()) {
        if (k == -1 || t.charAt(k) == t.charAt(j)) {
            k++;
            j++;
        }else{
            k = next[k];//前后缀长度缩减到原来k前面的最长前后缀对应的坐标
        }
    }
    return next;
}

对于朴素算法与kmp算法的测试代码如下：

public class NormalStringSearch {
    public static void main(String[] args) {
        String s = "aeiylahfsdjkh";
        String t = "fsd";
        int pos = find(s,t);
        int p = kmp(s,t);
        System.out.println("pos:"+pos);
    }
}

3、哈希表

应用：哈希表通常用来解决类似“在100000个单词中查找某个单词出现的次数”这种针对大数据中查找次数的问题，即用于海量数据处理：数据处理和求top k。
原理：
（1）普通哈希表
定义一个数组，将元素放入元素值与数组元素下标相同的位置，这样想要找到某元素只需要直接访问该数组下标位置的元素即可，时间复杂度仅为O(1)；
但是，如此一来假如给出的几个数据中某个数据值很大的话，创建数组就也很大，这样就有可能让创建的这个数组中有诸多空间被浪费，并未得到使用，所以常常用除留余数法并且将数组循环起来用；但如此一来，如果给出的数据有重复值，那么数组中此位置就有不止一个元素放在这里，这样就产生了哈希冲突（也叫哈希碰撞），由于哈希冲突的存在，哈希表的增删改查时间复杂度只能趋近为O(1)，却不为O(1)，可以用O(n)表示。
那么，如何解决哈希冲突呢？需要用**线性探测法：**通常是如果某一位置被占用，则原本该存放在此位置的元素顺次存到下一个位置，以此类推。
（2）链式哈希表
与普通哈希表一样，但不同的是处理哈希冲突时，是在当前位置以链表的形式存储产生哈希冲突的元素，大概是酱紫的，如下图：在这里插入图片描述
所以给出代码：
（1）线性哈希表的增删查操作：

import java.util.Arrays;

/**
 * 线性探测哈希表实现
 */
class LinerHashMap<T extends Comparable<T>>{
    // 散列表数组
    private Entry<T>[] hashTable;
    // 被占用的桶的个数
    private int usedBucketNum;
    // 哈希表的装载因子
    private double loadFactor;
    // 定义素数表
    private static int[] primTable;
    // 记录当前使用的素数的下标
    private int primIndex;
    // 类的静态初始化块
    static{
        primTable = new int[]{3, 7, 23, 47, 97, 127};
    }
    /**
     * 构造函数，初始化
     */
    public LinerHashMap(){
        this.primIndex = 0;
        this.hashTable = new Entry[primTable[this.primIndex]];
        this.usedBucketNum = 0;
        this.loadFactor = 0.75;
    }
    /**
     * 增加元素
     */
    public void put(T key){
        // 计算哈希表是否需要扩容
        double ret = this.usedBucketNum*1.0 / this.hashTable.length;
        if(ret > this.loadFactor){
            resize(); // 哈希表的扩容
        }
        // 先计算key应该放的桶的下标
        int index = key.hashCode() % this.hashTable.length;
        int idx = index;
        do{
            // 表示是从未使用过的桶
            if(this.hashTable[index] == null){
                this.hashTable[index] = new Entry<>(key, State.USING);
                this.usedBucketNum++;
                return;
            }
            // 表示使用过的桶
            if(this.hashTable[index].getState() == State.USED){
                this.hashTable[index].setData(key);
                this.hashTable[index].setState(State.USING);
                this.usedBucketNum++;
                return;
            } else {
                // 正在使用中的桶，不插入重复元素
                if(this.hashTable[index].getData().compareTo(key) == 0){
                    return;
                }
            }
            idx = (idx+1)%this.hashTable.length;
        } while(idx != index);
    }
    /**
     * 哈希表的扩容函数
     */
    private void resize() {
        Entry<T>[] oldHashTable = this.hashTable;
        this.hashTable = new Entry[primTable[++this.primIndex]];
        this.usedBucketNum = 0;

        for (int i = 0; i < oldHashTable.length; i++) {
            if(oldHashTable[i] != null
                    && oldHashTable[i].getState() == State.USING){
                this.put(oldHashTable[i].getData());
            }
        }
    }
    /**
     * 删除元素
     * @param key
     */
    public void remove(T key){
        // 先计算key应该放的桶的下标
        int index = key.hashCode() % this.hashTable.length;

        // 从当前位置开始找元素
        int idx = index;
        do{
            // 如果遍历桶的过程中，发现了从未使用过的桶，直接返回
            if(this.hashTable[idx] == null){
                return;
            }
            if(this.hashTable[idx].getState() == State.USING
                    && this.hashTable[idx].getData().compareTo(key) == 0){
                this.hashTable[idx].setData(null);
                this.hashTable[idx].setState(State.USED);
                this.usedBucketNum--;
                return;
            }
            idx = (idx+1)%this.hashTable.length;
        } while(idx != index);
    }
    /**
     * 查询元素  返回key的值，找不到返回null
     * HashMap
     */
    public T get(T key){
        // 先计算key应该放的桶的下标
        int index = key.hashCode() % this.hashTable.length;

        // 从当前位置开始找元素
        int idx = index;
        do{
            // 如果遍历桶的过程中，发现了从未使用过的桶，直接返回
            if(this.hashTable[idx] == null){
                return null;
            }
            if(this.hashTable[idx].getState() == State.USING
                    && this.hashTable[idx].getData().compareTo(key) == 0){
                return key;
            }
            idx = (idx+1)%this.hashTable.length;
        } while(idx != index);

        return null;
    }

    /**
     * 定义桶的状态值
     */
    static enum State{
        UNUSE,// 桶从未使用过
        USED,// 桶被用过了
        USING// 桶正在使用中
    }

    /**
     * 定义桶的元素类型
     * @param <T>
     */
    static class Entry<T extends Comparable<T>>{
        T data;
        State state;

        public Entry(T data, State state) {
            this.data = data;
            this.state = state;
        }

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }

        public State getState() {
            return state;
        }

        public void setState(State state) {
            this.state = state;
        }
    }
}

/*描述：线性哈希表的测试*/
public class LinerHashMapTest {
    public static void main(String[] args) {
        LinerHashMap<Integer> hash = new LinerHashMap<>();
        for(int i = 0;i < 20;i++){
            hash.put(i);
        }
        System.out.println(hash);
    }
}

4、字典树

应用：字典树常用来解决类似“在100000个单词中，以某前缀开头的单词有多少个”或者“某个单词出现了多少次”这样的问题。
字典树结构如下：在这里插入图片描述
字典树的时间复杂度为O(m)，其中m为待查找的字符串的长度。
代码稍后补上：

长河落日袁同学
关注
专栏目录
【Java】4种方法统计字符串中所有字符出现次数 - 优劣分析
Hello, New World!
03-03 2014
统计字符串中所有字符出现的次数的 3 种方法，总结如下： countChars1() 方法使用 for-for双重循环，逐个计数、检查重复； countChars2() 方法使用String的replace方法替换出相同字符，保存剩下的字符组成的字符串，最后长度相减，得出每个字符次数； countChars3() 方法使用new int[10]数组，以下标作为要统计的数字字符，以元素作为计数器进...
噢！查重原来是这样实现的啊！
god23bin的博客之地
10-22 1829
项目中有一个查重的需求，就类似论文查重这种的需求，我的组长已经写好了这个 Demo 了，我也挺感兴趣的，所以也看了看是如何实现的，看完后，感慨一声，噢！原来是这样实现的啊！现在呢，就记录下我从中学到的知识！
字符串搜索算法
zpoint's blog
04-10 1291
最近看到 mysql 文档说他字符串搜索用不用索引的问题 "select * where id like abc%" 如果是开头不为通配符并且查询这一段有索引的则大部分情况下会走索引进行查询，找出在 abc < x < abd 区间的内容 "select * where id like %abc%" 如果是 开头为通配符的则会用Boyer-Moore 算法去进行搜索 ...
C 语言中如何实现字符串的查找和替换？
2401_86074221的博客
07-11 598
空字符串、字符串长度为 0、内存不足等情况。在实际编程中，应该添加适当的错误检查和处理代码，以提高程序的健壮性。 C 语言中实现字符串的查找和替换可以通过基本的循环和字符串操作来完成，也可以利用标准库提供的函数结合一些辅助操作来实现。根据具体的需求和场景，选择合适的方法可以提高程序的效率和可读性。
字符串的查找
weixin_33694172的博客
03-10 127
要求：字符串查找即在主串X中查找是否包含子串Y，与字符串包含不同的是，字符串的查找必须是连续的，即Y中的子串必须在X中连续的出现才算。 如：string main_str="ABCDEF"; string sub_str_1="BCD"; string sub_str_2="ACD"; 则在主串main_str中能查找到子串sub_str_1,而不能查找到子串sub_str_2.所...
查找字符串
qq_44360851的博客
08-04 796
indexof
字符串【查找】方法
qq_42954795的博客
10-20 6091
x.split()--------使用某个字符将字符串分割成多个元素「默认使用空格分割，且默认整个字符串按从左向右的顺序都参与分割，也可以根据情况选定分割区域」x.removesuffix()--------将字符串中的某些后缀去掉。x.removeprefix()-------将字符串中的某些前缀去掉。x.replace()---------将制定的字符替换为目标字符。x.rsplit()--------字符串从右向左按条件分割。x.count()--------统计某个字符出现的次数。
kmp.zip_kmp查重_查重 kmp算法_进行字符串查
09-19
在本例中，"kmp.zip_kmp查重_查重 kmp算法_进行字符串查"的标题和描述表明，这是一个使用KMP算法实现字符串查重的项目，其中包含了Visual Studio 2012的工程文件。 KMP算法的核心思想是构建一个“部分匹配表”（也...
unordered_map 实现字符串数组查重
01-28
unordered_map可以用于实现字符串数组的查重。下面是一个示例代码： ```cpp #include #include #include #include int main() { std::vector<std::string> strVec = {"apple", "banana", "orange", "apple", ...
python 判断字符串查重_python简单实现论文查重（软工第一次项目作业）
weixin_39607873的博客
12-06 1561
前言本文涉及代码已上传个人GitHub题目：论文查重描述如下：设计一个论文查重算法，给出一个原文文件和一个在这份原文上经过了增删改的抄袭版论文的文件，在答案文件中输出其重复率。原文示例：今天是星期天，天气晴，今天晚上我要去看电影。抄袭版示例：今天是周天，天气晴朗，我晚上要去看电影。要求输入输出采用文件输入输出，规范如下：从命令行参数给出：论文原文的文件的绝对路径。从命令行参数给出：抄袭版论文的文件...
用c++实现一个查重功能，高效查找新的字符串是否有和之前相同的
最新发布
09-19
在C++中实现高效的字符串查重功能，通常我们会采用哈希集合（如`std::unordered_set`）或者排序数组结合二分查找的方式来提高查找速度。这里我们以`std::unordered_set`为例，因为它提供了常数时间复杂度的插入和...
字符串查找
BigBun_Wang的博客
11-09 331
        字符串查找需要先遍历整个字符串，然后在调用一些方法来实现相关的字符或字符串查找，或写一些接口来实现特定的需求。 public class WorldsCalc { public static void main(String[] args) { String str = “hello world”; ...
寻找字符串
ityanger的技术栈
05-24 2686
问题 : 寻找字符串时间限制: 1 Sec  内存限制: 128 MB题目描述对于一个字符串 s,定义一个函数 S(x),表示 s 中有多少个子串 x。现在给定 S(a),S(b),S(ab),S(ba)的值,求满足这 4 个值的字符串 s,如果有多个满足条件的字符串,输出字典序最小的。输入输入一个 T(T ≤ 50)表示 T 组数据。对于每组数据按顺序输入用空格分开的四个整数,分别表示 S(a)...
字符串查找算法
awesomeray
07-27 1455
总结下字符串匹配算法： BF（Burte Force）：暴力匹配算法。从主串第一个字符开始与模式串比对，若相等，则主串和模式串都后移一个字符继续比较；若不相同，则主串后移一个字符，模式串从第一个字符开始比较。知道模式串中的每个字符与主串的一个连续字符串相等，则匹配成功，返回模式串第一个字符在主串的位置；否则匹配失败。最坏情况下，为o(M*N)。 BM（Boyer Moore）算法： 时间复
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值