[Swift]LeetCode28. 实现strStr() | Implement strStr()

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9697924.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Implement strStr().

Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Example 1:

Input: haystack = "hello", needle = "ll"
Output: 2

Example 2:

Input: haystack = "aaaaa", needle = "bba"
Output: -1

Clarification:

What should we return when needle is an empty string? This is a great question to ask during an interview.

For the purpose of this problem, we will return 0 when needle is an empty string. This is consistent to C's strstr() and Java's indexOf().

---

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回  -1。

示例 1:

输入: haystack = "hello", needle = "ll"
输出: 2

示例 2:

输入: haystack = "aaaaa", needle = "bba"
输出: -1

说明:

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

---

 12ms

class Solution {
    func strStr(_ haystack: String, _ needle: String) -> Int {
        let count1 = haystack.count
        let count2 = needle.count
        if count2 == 0 {
            return 0
        }
        
        if count1 < count2 {
            return -1
        }
        
        var haystackChars = haystack.cString(using: .utf8)!
        var needleChars = needle.cString(using: .utf8)!
        var i = 0
        var j = 0
        
        let maxi = count1 - count2
        let maxj = count2 - 1
        
        while i <= maxi && j <= maxj {
            var m = i
            while m <= count1 - 1 && j <= maxj {
                let mv = haystackChars[m]
                let jv = needleChars[j]
                if mv == jv {
                    m += 1
                    j += 1
                    continue
                }
                j = 0
                i += 1
                break
            }
        }
        j = j - 1
        if j == maxj{
            return i
        }
        
        return -1
    }
}

---

16ms

class Solution {

func strStr(_ haystack: String, _ needle: String) -> Int {
    guard needle.count != 0 && !haystack.hasPrefix(needle) else{
        return 0
    }
    guard haystack.count != needle.count else {
        return -1
    }
    guard haystack.contains(needle) else {
        return -1
    }
   
    var stop = false
    var low = 0
    var high = haystack.count
    
    while !stop {
        let start = haystack.index(haystack.startIndex, offsetBy: low)
        let end = haystack.index(haystack.endIndex, offsetBy: high-haystack.count)
        let range = Range<String.Index>(uncheckedBounds: (lower: start, upper: end))
        
        let str = String(haystack[range])
  
        if str.count <= needle.count*3 {
            if str.hasPrefix(needle) {
                stop = true
                return low
            }else {
                low += 1
            }
        }else {
            let middle = str.count/2
            let prefixStr = str.prefix(middle + needle.count)
            if prefixStr.contains(needle) {
                if str.hasPrefix(needle) {
                    stop = true
                    return low
                }
                high -= middle
                high += needle.count
            }else {
                low += middle
                low -= needle.count
            }
        }
    }
  }
}

---

20ms

class Solution {
    func strStr(_ haystack: String, _ needle: String) -> Int {
        guard !needle.isEmpty else {
            return 0
        }
        let sCount = haystack.count, pCount = needle.count
        guard sCount >= pCount else {
            return -1
        }
        let s = Array(haystack), p = Array(needle)
        var i = 0, j = 0
        while i < s.count && j < p.count {
            if s[i] == p[j] {
                i += 1
                j += 1
            } else {
                i = i - j + 1
                j = 0
            }
        }
        return j == pCount ? i - j : -1
    }
}

---

24ms

class Solution {
    func strStr(_ haystack: String, _ needle: String) -> Int {
        if needle.count == 0 {
            return 0
        }

        if haystack.count == 0 {
            return -1
        }

        var search = haystack[haystack.startIndex..<haystack.endIndex]
        while search.count > 0 {
            if let first = search.firstIndex(of: needle.first!), let endindex = search.index(first, offsetBy: needle.count, limitedBy: search.endIndex) {
                let match = search[first..<endindex]
                if match == needle {
                    return haystack.distance(from: haystack.startIndex, to: first)
                }

                if first != search.endIndex {
                    if let b = search.index(first, offsetBy: 1, limitedBy: search.endIndex) {
                        search = search[b..<search.endIndex]
                    }
                }
            } else {
                break
            }
        }

        return -1
    }
}

---

28ms

class Solution {
    func strStr(_ haystack: String, _ needle: String) -> Int {
        let sCount = haystack.count, pCount = needle.count
        guard pCount > 0 && sCount >= pCount else {
            return pCount == 0 ? 0 : -1
        }
        let p = Array(needle)
        //为了提高效率，用空间换时间，初始化一个字典记录p中每个字符最后出现的位置
        var charDictionary = [Character: Int]()
        for index in stride(from: pCount - 1, through: 0, by: -1) {
            let char = p[index]
            if charDictionary[char] == nil {
                charDictionary[char] = index
            }
        }
        let s = Array(haystack)
        var i = 0, j = 0
        while i < sCount && j < pCount {
            if s[i] == p[j] {
                i += 1
                j += 1
            } else {
                let nextSCharIndex = i + (pCount - 1 - j) + 1
                if nextSCharIndex < sCount {
                    let nextSChar = s[nextSCharIndex]
                    if let index = charDictionary[nextSChar] {
                        i = i - j + pCount - 1 - index + 1
                    } else {
                        i = i - j + pCount + 1
                    }
                    j = 0
                } else {
                    break
                }
            }
        }
        return j == pCount ? i - j : -1
    }
}        

---

32ms

class Solution {
    func strStr(_ haystack: String, _ needle: String) -> Int {
        guard !needle.isEmpty else {
            return 0
        }
        let sCount = haystack.count, pCount = needle.count
        guard sCount >= pCount else {
            return -1
        }
        let s = Array(haystack), p = Array(needle)
        var next = Array(repeating: -1, count: pCount)
        var k = -1, j = 0
        while j < pCount - 1 {
            if k == -1 || p[j] == p[k] {
                j += 1
                k += 1
                if p[j] != p[k] {
                    next[j] = k
                } else {
                    next[j] = next[k]
                }
            } else {
                k = next[k]
            }
        }
        var i = 0
        j = 0
        while i < s.count && j < p.count {
            if j == -1 || s[i] == p[j] {
                i += 1
                j += 1
            } else {
                j = next[j]
            }
        }
        return j == pCount ? i - j : -1
    }
}

---

44ms

class Solution {
    func strStr(_ haystack: String, _ needle: String) -> Int {   
        //当 needle 是空字符串时应当返回 0
        if needle.isEmpty{return 0}
        //获取字符的长度
        let haystackLen = haystack.count
        let needleLen = needle.count
        //haystack字符串字符长度小于needle字符串，则返回-1
        if haystackLen < needleLen{return -1}
        //needle的第一个字符
        let firstChar = needle[needle.startIndex]
        //遍历haystack字符串,讲Int转化为String.Index
        for i in 0...haystackLen-needleLen
        {
            //截取字符串的开始处索引
            let firstIndex = haystack.index(haystack.startIndex, offsetBy: i)
            //截取字符串的结束处索引
            let endIndex = haystack.index(haystack.startIndex, offsetBy: i + needleLen)
            //截取字符串，注意要用String.Index的方式访问字符串
            let subStr = haystack[firstIndex..<endIndex]
            //判断截取的字符串是否等于needle
            if subStr == needle
            {
                //返回索引
                return i
            }              
        }
        //没有匹配，返回-1
        return -1
    }
}

---

52ms

class Solution {
    func strStr(_ haystack: String, _ needle: String) -> Int {
        guard !needle.isEmpty else { return 0 }
        guard needle.count <= haystack.count else { return -1 }
        for i in 0...(haystack.count-needle.count) {
            let substr = String(Array(haystack)[i..<(i+needle.count)])
            if substr == needle {
                return i
            }
        }
        return -1
    }
}