首页

前端系统进阶笔记 & 面试指南

技术专栏

掘金热门

阅读

ONE_文章

ONE_问答

后端&架构

前端&移动

深入浅出搞定 React

解读你身边的经济学

TypeScript 入门实战笔记

姜承尧的MySQL实战宝典

前端进击笔记

数据分析

职场&管理

其他

前端性能优化方法与实战

市场&运营

14 讲提升职场竞争力

Spring Security 详解与实操

Vue.js 3.0 核心源码内参

计算机网络通关 29 讲

32个Java面试必考点

300分钟搞定数据结构与算法

分布式技术原理与实战45讲

Go 微服务实战 38 讲

Dubbo源码解读与实战

分布式链路追踪实战

52讲轻松搞定网络爬虫

深入浅出 Java 虚拟机

架构师的 36 项修炼

Spring 响应式编程实战

应用性能分析实战

趣学设计模式

SpringCloud Alibaba 实战

iOS开发进阶

数据结构与算法面试宝典

21讲吃透实时流计算

产品&设计

大数据&AI

23讲搞定后台架构实战

测试&运维

微服务Service Mesh原理与实战

打造千万级流量秒杀系统

前端基础建设与架构 30 讲

Web 安全攻防之道

架构设计面试精讲

数据挖掘思维与实战 24 讲

重学操作系统

JavaScript 核心原理精讲

软件架构场景实战 22 讲

Flutter快学快用24讲

前端面试宝典之 React 篇

DevOps 落地笔记

Spring Boot 实战开发

跟着华为学管理

DDD 微服务落地实战

人人都能学会的数据分析

成为会带团队的技术人

22 讲通关 Go 语言

产品体验设计思维与实操

Spring Cloud 原理与实战

12步通关求职面试

云原生微信小程序开发实战

程序员的数学课

24讲吃透分布式数据库

Netty 核心原理剖析与 RPC 实践

大数据技术基础 22 讲

极简 OKR 实战

测试开发入门与实战

深入剖析 MyBatis 核心原理

Kubernetes 原理剖析与实战应用

由浅入深吃透 Docker

etcd 原理与实践

前端工程化精讲

高效敏捷测试 49 讲

Java 性能优化实战 21 讲

玩转 Serverless 架构

OKR：组织敏捷目标和绩效管理

前端高手进阶

ShardingSphere 核心原理精讲

ZooKeeper源码分析与实战

大数据运维实战

数据分析思维与实战 23 讲

42讲轻松通关 Flink

即学即用的Spark实战44讲

Android 工程师进阶 34 讲

Webpack原理与实践

云原生微服务架构实战精讲

31 讲带你搞懂 SkyWalking

Java 源码剖析 34 讲

数据结构精讲：从原理到实战

运维高手的36项修炼

测试开发核心技术 46 讲

Java 并发编程 78 讲

300分钟吃透分布式缓存

高性能MySQL实战

300分钟搞懂 Spring Cloud

说透性能测试

这一节我们来讲字符串和它的相关操作。
<h3 data-nodeid="1134">字符串是什么</h3>
字符串（string） 是由 n 个字符组成的一个有序整体（ n &gt;= 0 ）。例如，s = "BEIJING" ，s 代表这个串的串名，BEIJING 是串的值。这里的双引号不是串的值，作用只是为了将串和其他结构区分开。字符串的逻辑结构和线性表很相似，不同之处在于字符串针对的是字符集，也就是字符串中的元素都是字符，线性表则没有这些限制。
在实际操作中，我们经常会用到一些特殊的字符串：
<ul data-nodeid="1137">
<li data-nodeid="1138">
空串，指含有零个字符的串。例如，s = ""，书面中也可以直接用 Ø 表示。
</li>
<li data-nodeid="1140">
空格串，只包含空格的串。它和空串是不一样的，空格串中是有内容的，只不过包含的是空格，且空格串中可以包含多个空格。例如，s = "&nbsp;&nbsp; "，就是包含了 3 个空格的字符串。
</li>
<li data-nodeid="1142">
子串，串中任意连续字符组成的字符串叫作该串的子串。
</li>
<li data-nodeid="1144">
原串通常也称为主串。例如：a = "BEI"，b = "BEIJING"，c = "BJINGEI" 。
<ul data-nodeid="1146">
<li data-nodeid="1147">
对于字符串 a 和 b 来说，由于 b 中含有字符串 a ，所以可以称 a 是 b 的子串，b 是 a 的主串；
</li>
<li data-nodeid="1149">
而对于 c 和 a 而言，虽然 c 中也含有 a 的全部字符，但不是连续的 "BEI" ，所以串 c 和 a 没有任何关系。
</li>
</ul>
</li>
</ul>
当要判断两个串是否相等的时候，就需要定义相等的标准了。只有两个串的串值完全相同，这两个串才相等。根据这个定义可见，即使两个字符串包含的字符完全一致，它们也不一定是相等的。例如 b = "BEIJING"，c = "BJINGEI"，则 b 和 c 并不相等。
字符串的存储结构与线性表相同，也有顺序存储和链式存储两种。
<ul data-nodeid="1153">
<li data-nodeid="1154">
字符串的顺序存储结构，是用一组地址连续的存储单元来存储串中的字符序列，一般是用定长数组来实现。有些语言会在串值后面加一个不计入串长度的结束标记符，比如 \0 来表示串值的终结。
</li>
<li data-nodeid="1156">
字符串的链式存储结构，与线性表是相似的，但由于串结构的特殊性（结构中的每个元素数据都是一个字符），如果也简单地将每个链结点存储为一个字符，就会造成很大的空间浪费。因此，一个结点可以考虑存放多个字符，如果最后一个结点未被占满时，可以使用 "#" 或其他非串值字符补全，如下图所示：
</li>
</ul>
<img src="https://s0.lgstatic.com/i/image/M00/1C/BB/Ciqc1F7gvwmAeOuQAACbWbwi7hs491.png" alt="1.png" data-nodeid="1279">
在链式存储中，每个结点设置字符数量的多少，与串的长度、可以占用的存储空间以及程序实现的功能相关。
<ul data-nodeid="1160">
<li data-nodeid="1161">
如果字符串中包含的数据量很大，但是可用的存储空间有限，那么就需要提高空间利用率，相应地减少结点数量。
</li>
<li data-nodeid="1163">
而如果程序中需要大量地插入或者删除数据，如果每个节点包含的字符过多，操作字符就会变得很麻烦，为实现功能增加了障碍。
</li>
</ul>
因此，串的链式存储结构除了在连接串与串操作时有一定的方便之外，总的来说，不如顺序存储灵活，在性能方面也不如顺序存储结构好。
<h3 data-nodeid="1166">字符串的基本操作</h3>
字符串和线性表的操作很相似，但由于字符串针对的是字符集，所有元素都是字符，因此字符串的基本操作与线性表有很大差别。线性表更关注的是单个元素的操作，比如增删查一个元素，而字符串中更多关注的是查找子串的位置、替换等操作。接下来我们以顺序存储为例，详细介绍一下字符串对于另一个字符串的增删查操作。
<h4 data-nodeid="1168">字符串的新增操作</h4>
字符串的新增操作和数组非常相似，都牵涉对插入字符串之后字符的挪移操作，所以时间复杂度是 O(n)。
例如，在字符串 s1 = "123456" 的正中间插入 s2 = "abc"，则需要让 s1 中的 "456" 向后挪移 3 个字符的位置，再让 s2 的 "abc" 插入进来。很显然，挪移的操作时间复杂度是 O(n)。不过，对于特殊的插入操作时间复杂度也可以降低为 O(1)。这就是在 s1 的最后插入 s2，也叫作字符串的连接，最终得到 "123456abc"。
<h4 data-nodeid="1171">字符串的删除操作</h4>
字符串的删除操作和数组同样非常相似，也可能会牵涉删除字符串后字符的挪移操作，所以时间复杂度是 O(n)。
例如，在字符串 s1 = "123456" 的正中间删除两个字符 "34"，则需要删除 "34" 并让 s1 中的 "56" 向前挪移 2 个字符的位置。很显然，挪移的操作时间复杂度是 O(n)。不过，对于特殊的插入操作时间复杂度也可以降低为 O(1)。这就是在 s1 的最后删除若干个字符，不牵涉任何字符的挪移。
<h4 data-nodeid="1174">字符串的查找操作</h4>
字符串的查找操作，是反映工程师对字符串理解深度的高频考点，这里需要你格外注意。
例如，字符串 s = "goodgoogle"，判断字符串 t = "google" 在 s 中是否存在。需要注意的是，如果字符串 t 的每个字符都在 s 中出现过，这并不能证明字符串 t 在 s 中出现了。当 t = "dog" 时，那么字符 "d"、"o"、"g" 都在 s 中出现过，但他们并不连在一起。
那么我们如何判断一个子串是否在字符串中出现过呢？这个问题也被称作子串查找或字符串匹配，接下来我们来重点分析。
<h4 data-nodeid="1178">子串查找（字符串匹配）</h4>
首先，我们来定义两个概念，主串和模式串。我们在字符串 A 中查找字符串 B，则 A 就是主串，B 就是模式串。我们把主串的长度记为 n，模式串长度记为 m。由于是在主串中查找模式串，因此，主串的长度肯定比模式串长，n&gt;m。因此，字符串匹配算法的时间复杂度就是 n 和 m 的函数。
假设要从主串 s = "goodgoogle" 中找到 t = "google" 子串。根据我们的思考逻辑，则有：
<ul data-nodeid="1181">
<li data-nodeid="1182">
首先，我们从主串 s 第 1 位开始，判断 s 的第 1 个字符是否与 t 的第 1 个字符相等。
</li>
<li data-nodeid="1184">
如果不相等，则继续判断主串的第 2 个字符是否与 t 的第1 个字符相等。直到在 s 中找到与 t 第一个字符相等的字符时，然后开始判断它之后的字符是否仍然与 t 的后续字符相等。
</li>
<li data-nodeid="1186">
如果持续相等直到 t 的最后一个字符，则匹配成功。
</li>
<li data-nodeid="1188">
如果发现一个不等的字符，则重新回到前面的步骤中，查找 s 中是否有字符与 t 的第一个字符相等。
</li>
<li data-nodeid="1190">
如下图所示，s 的第1 个字符和 t 的第 1 个字符相等，则开始匹配后续。直到发现前三个字母都匹配成功，但 s 的第 4 个字母匹配失败，则回到主串继续寻找和 t 的第一个字符相等的字符。
</li>
<li data-nodeid="1192">
如下图所示，这时我们发现主串 s 第 5 位开始相等，并且随后的 6 个字母全匹配成功，则找到结果。
</li>
</ul>
<img src="https://s0.lgstatic.com/i/image/M00/1D/7B/Ciqc1F7h-hmAFsw0ADCjkl8SW7M434.gif" alt="Lark20200611-171750.gif" data-nodeid="1375">
这种匹配算法需要从主串中找到跟模式串的第 1 个字符相等的位置，然后再去匹配后续字符是否与模式串相等。显然，从实现的角度来看，需要两层的循环。第一层循环，去查找第一个字符相等的位置，第二层循环基于此去匹配后续字符是否相等。因此，这种匹配算法的时间复杂度为 O(nm)。其代码如下：
<pre class="lang-java" data-nodeid="1196"><code data-language="java">public void s1() {
 String s = "goodgoogle";
 String t = "google";
 int isfind = 0;

 for (int i = 0; i &lt; s.length() - t.length() + 1; i++) {
 if (s.charAt(i) == t.charAt(0)) {
 int jc = 0;
 for (int j = 0; j &lt; t.length(); j++) {
 if (s.charAt(i + j) != t.charAt(j)) {
 break;
 }
 jc = j;
 }
 if (jc == t.length() - 1) {
 isfind = 1;
 }
 }
 }
 System.out.println(isfind);
}
</code></pre>
<h3 data-nodeid="1197">字符串匹配算法的案例</h3>
最后我们给出一道面试中常见的高频题目，这也是对字符串匹配算法进行拓展，从而衍生出的问题，即查找出两个字符串的最大公共字串。
假设有且仅有 1 个最大公共子串。比如，输入 a = "13452439"， b = "123456"。由于字符串 "345" 同时在 a 和 b 中出现，且是同时出现在 a 和 b 中的最长子串。因此输出 "345"。








对于这个问题其实可以用动态规划的方法来解决，关于动态规划，我们会在后续的课程会讲到，所以在这里我们沿用前面的匹配算法。
假设字符串 a 的长度为 n，字符串 b 的长度为 m，可见时间复杂度是 n 和 m 的函数。
<ul data-nodeid="1202">
<li data-nodeid="1203">
首先，你需要对于字符串 a 和 b 找到第一个共同出现的字符，这跟前面讲到的匹配算法在主串中查找第一个模式串字符一样。
</li>
<li data-nodeid="1205">
然后，一旦找到了第一个匹配的字符之后，就可以同时在 a 和 b 中继续匹配它后续的字符是否相等。这样 a 和 b 中每个互相匹配的字串都会被访问一遍。全局还要维护一个最长子串及其长度的变量，就可以完成了。
</li>
</ul>
从代码结构来看，第一步需要两层的循环去查找共同出现的字符，这就是 O(nm)。一旦找到了共同出现的字符之后，还需要再继续查找共同出现的字符串，这也就是又嵌套了一层循环。可见最终的时间复杂度是 O(nmm)，即 O(nm²)。代码如下：
<pre class="lang-java" data-nodeid="1208"><code data-language="java">public void s2() {
 String a = "123456";
 String b = "13452439";
 String maxSubStr = "";
 int max_len = 0;
		
 for (int i = 0; i &lt; a.length(); i++) {
 for (int j = 0; j &lt; b.length(); j++){
 if (a.charAt(i) == b.charAt(j)){
 for (int m=i, n=j; m&lt;a.length()&amp;&amp;n&lt;b.length(); m++,n++) {
 if (a.charAt(m) != b.charAt(n)){
 break;
 }
 if (max_len &lt; m-i+1){
 max_len = m-i+1;
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; maxSubStr = a.substring(i, m+1);
 }
 }
 }
 }	
 }
 System.out.println(maxSubStr);
}
</code></pre>
<h3 data-nodeid="1209">总结</h3>
这节课我们介绍了字符串匹配算法，它在平时代码编写中都比较常用。
字符串的逻辑结构和线性表极为相似，区别仅在于串的数据对象约束为字符集。但是，字符串的基本操作和线性表有很大差别：
<ul data-nodeid="1212">
<li data-nodeid="1213">
在线性表的基本操作中，大多以“单个元素”作为操作对象；
</li>
<li data-nodeid="1215">
在字符串的基本操作中，通常以“串的整体”作为操作对象；
</li>
<li data-nodeid="1217">
字符串的增删操作和数组很像，复杂度也与之一样。但字符串的查找操作就复杂多了，它是参加面试、笔试常常被考察的内容。
</li>
</ul>
<h3 data-nodeid="1219">练习题</h3>
最后我们给出一道练习题。给定一个字符串，逐个翻转字符串中的每个单词。例如，输入: "the sky is blue"，输出: "blue is sky the"。
希望你在课后自己去实践一下，如果你在字符串的使用方面遇到困难，欢迎在留言区和我交流。

国内首批从事机器学习和数据挖掘的工程师，拥有深厚的一线代码开发经验，对数据结构、算法思想有多年研究和深入理解，热衷于知识分享和技能输出。

08 | 字符串：如何正确回答面试中高频考察的字符串匹配算法？