LeetCode面试150——28找出字符串中第一个匹配项的下标

沈小农学编程

于 2024-08-11 10:14:36 发布

阅读量953

点赞数 14

分类专栏： LeetCode 文章标签： leetcode 面试算法 python c++ 职场和发展 java

本文链接：https://blog.csdn.net/Junmo12345/article/details/141101982

版权

LeetCode 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

题目难度：简单

默认优化目标：最小化平均时间复杂度。

Python默认为Python3。

1 题目描述

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

提示：

1 <= haystack.length, needle.length <= 104
haystack 和 needle 仅由小写英文字符组成

2 题目解析

输入是两个字符串haystack 和 needle ，输出是 needle第一个和haystack中字符串匹配的位置，如果没有返回-1。

3 算法原理及代码实现

3.1 暴力求解

让needle与haystack所有长度为m的字串匹配一遍，m为needle的长度，n为haystack的长度。

为了提高运行速度，当匹配失败终止继续匹配，返回-1。

平均时间复杂度O(mn)，平均空间复杂度O(1)。

C++代码实现

class Solution {
public:
    int strStr(string haystack, string needle) {
        int n=haystack.size(),m=needle.size();

        for(int i=0;i<=n-m;i++){
            bool flag=true;
            for(int j=0;j<m;j++){
                if(haystack[i+j]!=needle[j]){
                    flag=false;
                    break;
                }
            }
            if(flag){
                return i;
            }
        }

        return -1;

    }
};

Python代码实现

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        n, m = len(haystack), len(needle)

        for i in range(n - m + 1):
            flag = True
            for j in range(m):
                if haystack[i + j] != needle[j]:
                    flag = False
                    break
            if flag:
                return i

        return -1

Java代码实现

class Solution {
    public int strStr(String haystack, String needle) {
        int n = haystack.length();
        int m = needle.length();

        for (int i = 0; i <= n - m; i++) {
            boolean flag = true;
            for (int j = 0; j < m; j++) {
                if (haystack.charAt(i + j) != needle.charAt(j)) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                return i;
            }
        }

        return -1;
    }
}

3.2 自带函数

我们也可以使用各语言自带的函数。

平均时间复杂度O(mn)，平均空间复杂度O(1)。

C++代码实现

class Solution {
public:
    int strStr(string haystack, string needle) {
        return haystack.find(needle);
    }
};

Python代码实现

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        return haystack.find(needle)

Java代码实现

class Solution {
    public int strStr(String haystack, String needle) {
        return haystack.indexOf(needle);
    }
}

3.3 KMP算法

KMP算法，全称Knuth-Morris-Pratt 算法，其核心算法为前缀函数，记作 π(i)，其定义如下：

对于长度为 m 的字符串 s，其前缀函数 π(i)(0≤i<m) 表示 s 的子串 s[0:i] 的最长的相等的真前缀与真后缀的长度。特别地，如果不存在符合条件的前后缀，那么 π(i)=0。其中真前缀与真后缀的定义为不等于自身的的前缀与后缀。

步骤如下：

第一部分是求 needle 部分的前缀函数，我们需要保留这部分的前缀函数值。

第二部分是求 haystack 部分的前缀函数，我们无需保留这部分的前缀函数值，只需要用一个变量记录上一个位置的前缀函数值即可。当某个位置的前缀函数值等于 m 时，说明我们就找到了一次字符串 needle 在字符串 haystack 中的出现（因为此时真前缀恰为字符串 needle，真后缀为以当前位置为结束位置的字符串 haystack 的子串），我们计算出起始位置，将其返回即可。

平均时间复杂度O(m+n)，平均空间复杂度O(m)

C++代码实现

class Solution {
public:
    int strStr(string haystack, string needle) {
        int n = haystack.size(), m = needle.size();
        if (m == 0) {
            return 0;
        }
        //确定前缀数组
        vector<int> pi(m);
        for (int i = 1, j = 0; i < m; i++) {
            while (j > 0 && needle[i] != needle[j]) {
                j = pi[j - 1];
            }
            if (needle[i] == needle[j]) {
                j++;
            }
            pi[i] = j;
        }
        //匹配
        for (int i = 0, j = 0; i < n; i++) {
            while (j > 0 && haystack[i] != needle[j]) {
                j = pi[j - 1];
            }
            if (haystack[i] == needle[j]) {
                j++;
            }
            if (j == m) {
                return i - m + 1;
            }
        }
        return -1;
    }
};

Python代码实现

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        n, m = len(haystack), len(needle)
        if m == 0:
            return 0
        pi = [0] * m
        j = 0
        for i in range(1, m):
            while j > 0 and needle[i] != needle[j]:
                j = pi[j - 1]
            if needle[i] == needle[j]:
                j += 1
            pi[i] = j
        j = 0
        for i in range(n):
            while j > 0 and haystack[i] != needle[j]:
                j = pi[j - 1]
            if haystack[i] == needle[j]:
                j += 1
            if j == m:
                return i - m + 1
        return -1

Java代码实现

class Solution {
    public int strStr(String haystack, String needle) {
        int n = haystack.length();
        int m = needle.length();
        if (m == 0) {
            return 0;
        }
        int[] pi = new int[m];
        for (int i = 1, j = 0; i < m; i++) {
            while (j > 0 && needle.charAt(i) != needle.charAt(j)) {
                j = pi[j - 1];
            }
            if (needle.charAt(i) == needle.charAt(j)) {
                j++;
            }
            pi[i] = j;
        }
        for (int i = 0, j = 0; i < n; i++) {
            while (j > 0 && haystack.charAt(i) != needle.charAt(j)) {
                j = pi[j - 1];
            }
            if (haystack.charAt(i) == needle.charAt(j)) {
                j++;
            }
            if (j == m) {
                return i - m + 1;
            }
        }
        return -1;
    }
}

3.4 Boyer-Moore算法

我们用数组badChar记录needle中字符最后出现的位置，用数组goodSuffix确定匹配失败时字符串的移动距离。在匹配阶段，从左到右扫描haystack，尝试将其与needle匹配。成功返回位置，失败根据badChar和goodSuffix确定移动距离，并继续匹配。

平均时间复杂度O(n/m)，平均空间复杂度为O(m)。

C++代码实现

class Solution {
public:
    int strStr(string haystack, string needle) {
        int n = haystack.size(), m = needle.size();
        if (m == 0) {
            return 0;
        }

        // 预处理坏字符规则
        vector<int> badChar(256, -1);
        for (int i = 0; i < m; i++) {
            badChar[(int)needle[i]] = i;
        }

        // 预处理好后缀规则
        vector<int> goodSuffix(m, m);
        vector<int> suffix(m, -1);
        suffix[m - 1] = m;
        for (int i = m - 2; i >= 0; i--) {
            int j = i;
            while (j >= 0 && needle[j] == needle[m - 1 - i + j]) {
                j--;
            }
            suffix[i] = i - j;
        }
        for (int i = 0; i < m; i++) {
            goodSuffix[i] = m;
        }
        for (int i = m - 1; i >= 0; i--) {
            if (suffix[i] == i + 1) {
                for (int j = 0; j < m - 1 - i; j++) {
                    if (goodSuffix[j] == m) {
                        goodSuffix[j] = m - 1 - i;
                    }
                }
            }
        }
        for (int i = 0; i <= m - 2; i++) {
            goodSuffix[m - 1 - suffix[i]] = m - 1 - i;
        }

        // 开始匹配
        int s = 0;
        while (s <= n - m) {
            int j = m - 1;
            while (j >= 0 && needle[j] == haystack[s + j]) {
                j--;
            }
            if (j < 0) {
                return s;
            } else {
                s += max(goodSuffix[j], j - badChar[(int)haystack[s + j]]);
            }
        }
        return -1;
    }
};

Python代码实现

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        n, m = len(haystack), len(needle)
        if m == 0:
            return 0

        badChar = [-1] * 256
        for i in range(m):
            badChar[ord(needle[i])] = i

        goodSuffix = [m] * m
        suffix = [-1] * m
        suffix[m - 1] = m
        for i in range(m - 2, -1, -1):
            j = i
            while j >= 0 and needle[j] == needle[m - 1 - i + j]:
                j -= 1
            suffix[i] = i - j

        for i in range(m):
            goodSuffix[i] = m
        for i in range(m - 1, -1, -1):
            if suffix[i] == i + 1:
                for j in range(m - 1 - i):
                    if goodSuffix[j] == m:
                        goodSuffix[j] = m - 1 - i
        for i in range(m - 1):
            goodSuffix[m - 1 - suffix[i]] = m - 1 - i

        s = 0
        while s <= n - m:
            j = m - 1
            while j >= 0 and needle[j] == haystack[s + j]:
                j -= 1
            if j < 0:
                return s
            else:
                s += max(goodSuffix[j], j - badChar[ord(haystack[s + j])])
        return -1

Java代码实现

class Solution {
    public int strStr(String haystack, String needle) {
        int n = haystack.length(), m = needle.length();
        if (m == 0) return 0;

        int[] badChar = new int[256];
        for (int i = 0; i < 256; i++) badChar[i] = -1;
        for (int i = 0; i < m; i++) badChar[needle.charAt(i)] = i;

        int[] goodSuffix = new int[m], suffix = new int[m];
        for (int i = 0; i < m; i++) goodSuffix[i] = m;
        suffix[m - 1] = m;
        for (int i = m - 2; i >= 0; i--) {
            int j = i;
            while (j >= 0 && needle.charAt(j) == needle.charAt(m - 1 - i + j)) j--;
            suffix[i] = i - j;
        }
        for (int i = m - 1; i >= 0; i--) {
            if (suffix[i] == i + 1) {
                for (int j = 0; j < m - 1 - i; j++) {
                    if (goodSuffix[j] == m) goodSuffix[j] = m - 1 - i;
                }
            }
        }
        for (int i = 0; i <= m - 2; i++) goodSuffix[m - 1 - suffix[i]] = m - 1 - i;

        int s = 0;
        while (s <= n - m) {
            int j = m - 1;
            while (j >= 0 && needle.charAt(j) == haystack.charAt(s + j)) j--;
            if (j < 0) return s;
            else s += Math.max(goodSuffix[j], j - badChar[haystack.charAt(s + j)]);
        }
        return -1;
    }
}