🎨 update: string

Author: ConardLi

docs/.vuepress/config.js

@@ -86,6 +86,17 @@ module.exports = {
                         '/dataStructure/栈和队列/栈的压入弹出序列',
                     ]
                 },
+                {
+                    title: '字符串',
+                    children: [
+                        '/dataStructure/字符串/表示数值的字符串',
+                        '/dataStructure/字符串/替换空格',
+                        '/dataStructure/字符串/正则表达式匹配',
+                        '/dataStructure/字符串/字符串的排列',
+                        '/dataStructure/字符串/字符串翻转',
+                        '/dataStructure/字符串/字符流中第一个不重复的字符',
+                    ]
+                },
             ]
         }
     }

docs/dataStructure/字符串/字符串的排列.md

@@ -0,0 +1,85 @@
+---
+{
+  "title": "字符串的排列",
+}
+---
+
+## 题目
+
+输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串`abc`,则打印出由字符`a,b,c`所能排列出来的所有字符串`abc,acb,bac,bca,cab`和`cba`。
+
+## 思路
+
+使用回溯法
+
+记录一个字符（`temp`），用于存储当前需要进入排列的字符
+
+记录一个字符串（`current`），用于记录当前已经排列好的字符
+
+记录一个队列（`queue`），用于存储还未被排列的字符
+
+- 每次排列将`temp`添加到`current`
+- 如果`queue`为空，则本次排列完成，将`curret`加入到结果数组中，结束递归
+- 如果`queue`不为空，说明还有未排列的字符
+- 递归排列`queue`中剩余的字符
+- 为了不影响后续排列，每次递归完成，将当前递归的字符`temp`加回队列
+
+## 代码
+
+> 记录一个当前排列字符temp
+
+```js
+    function Permutation(str) {
+      const result = [];
+      if (str) {
+        queue = str.split('')
+        PermutationCore(queue, result);
+      }
+      result.sort();
+      return [... new Set(result)];
+    }
+
+    function PermutationCore(queue, result, temp = "", current = "") {
+      current += temp;
+      if (queue.length === 0) {
+        result.push(current);
+        return;
+      }
+      for (let i = 0; i < queue.length; i++) {
+        temp = queue.shift();
+        PermutationCore(queue, result, temp, current);
+        queue.push(temp);
+      }
+    }
+```
+
+> 记录一个当前索引，不断交换数组中的元素（不太好理解，不推荐）
+
+```js
+    function Permutation(str) {
+      var result = [];
+      if (!str) {
+        return result;
+      }
+      var array = str.split('');
+      permutate(array, 0, result);
+      result.sort();
+      return [... new Set(result)];
+    }
+
+    function permutate(array, index, result) {
+      if (array.length - 1 === index) {
+        result.push(array.join(''));
+      }
+      for (let i = index; i < array.length; i++) {
+        swap(array, index, i);
+        permutate(array, index + 1, result);
+        swap(array, i, index);
+      }
+    }
+```
+
+## 考察点
+
+- 字符串
+- 回溯算法

docs/dataStructure/字符串/字符串翻转.md

@@ -0,0 +1,57 @@
+---
+{
+  "title": "字符串翻转",
+}
+---
+
+## 题目1-翻转单词顺序
+
+输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串`"I am a student."`，则输出`"student. a am I"`。
+
+## 代码
+
+直接调用数组`API`进行翻转，没啥好讲的。
+
+```js
+function ReverseSentence(str)
+{
+    if(!str){return ''}
+    return str.split(' ').reverse().join(' ');
+}
+```
+
+## 题目2-左旋转字符串
+
+字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如输入字符串`"abcdefg"`和数字`2`，该函数将返回左旋转2位得到的结果`"cdefgab"`。
+
+## 代码
+
+将两个`str`进行拼接，直接从第`n`位开始截取，就相当于将前面`n`个数字移到末尾。
+
+```js
+function LeftRotateString(str, n)
+{
+    if(str&&n!=null){
+       return (str+str).substr(n)
+    }else{
+        return ''
+    }
+}
+```
+## 剑指offer中的思路
+
+上面两个问题都可以用简单的方法解决，《剑指offer》中的解法稍微有些复杂，我不推荐用，但是思路可以参考下：
+
+### 翻转单词顺序：
+
+- 第一步将整个字符串翻转，`"I am a student."` -> `".tneduts a ma I"`
+
+- 第二步将字符串内的单个字符串进行翻转：`".tneduts a ma I"` -> `"student. a am I"`
+
+### 左旋转字符串：
+
+以`"abcdefg"`为例，将字符串分为两部分`ab`和`cdefg`
+
+将两部分分别进行翻转，得到 -> `"bagfedc"`
+
+再将整个字符串进行翻转，得到 ->  `"cdefgab"`

docs/dataStructure/字符串/字符流中第一个不重复的字符.md

@@ -0,0 +1,75 @@
+---
+{
+  "title": "字符流中第一个不重复的字符",
+}
+---
+
+## 题目
+
+请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。
+当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
+
+如果当前字符流没有存在出现一次的字符，返回#字符。
+
+## 思路
+
+要求获得第一个只出现一次的。
+
+~~使用一个有序的存储结构为每个字符计数，再遍历这个对象，第一个出现次数为1的即为结果。~~
+
+~~在JavaScript中有序存储空间选择对象即可。~~
+
+上述解决办法是有问题的，因为在`JavaScript`中对象遍历并不是在所有浏览器中的实现都是有序的，而且直接使用对象存储，当字符流中出现数字时也是有问题的。
+
+所以下面改用剑指offer中的解法：
+
+- 创建一个长度为`256`的数组`container`来标记字符流中字符出现的次数
+
+- 使用字符`ASCII`码作为下标，这样数组长度最大为`256`
+
+- 当字符没有出现过，标记为`-1`
+
+- 当字符只出现一次，标记为字符在字符流中的位置`index`
+
+- 当字符出现多次时，标记为`-2`
+
+- 当调用`FirstAppearingOnce`时，只需要找到，数组值大于`-1`的且值最小的位置索引，即为第一个出现次数为`1`的字符
+
+
+
+## 代码
+
+```js
+    let container = new Array(256).fill(-1);
+    let index = 0;
+    function Init() {
+      container = new Array(256).fill(-1);
+      index = 0;
+    }
+    function Insert(ch) {
+      const code = ch.charCodeAt(0);
+      if (container[code] === -1) {
+        container[code] = index;
+      } else if (container[code] >= 0) {
+        container[code] = -2;
+      }
+      index++;
+    }
+    function FirstAppearingOnce() {
+      let minIndex = 256;
+      let strIndex = 0;
+      for (let i = 0; i < 256; i++) {
+        if (container[i] >= 0 && container[i] < minIndex) {
+          minIndex = container[i];
+          strIndex = i;
+        }
+      }
+      return minIndex === 256 ? '#' : String.fromCharCode(strIndex);
+    }
+```
+
+
+## 考察点
+
+- 字符串
+- hash

docs/dataStructure/字符串/替换空格.md

@@ -0,0 +1,49 @@
+---
+{
+  "title": "替换空格",
+}
+---
+
+## 题目
+
+请实现一个函数，将一个字符串中的每个空格替换成`“%20”`。例如，当字符串为`We Are Happy`。则经过替换之后的字符串为`We%20Are%20Happy`。
+
+
+## 代码
+
+1.直接用空格将字符串切割成数组，再用`20%`进行连接。
+
+```js
+function replaceSpace(str)
+{
+    return str.split(' ').join('%20');
+}
+```
+
+2.用正则表达式找到所有空格依次替换
+
+```js
+function replaceSpace(str)
+{
+    return str.replace(/\s/g,'%20');
+}
+```
+
+## 拓展
+
+允许出现多个空格，多个空格用一个`20%`替换：
+
+用正则表达式找到连续空格进行替换
+
+```js
+function replaceSpace(str)
+{
+    return str.replace(/\s+/g,'%20');
+}
+```
+
+
+## 考察点
+
+- 字符串
+- 正则

docs/dataStructure/字符串/正则表达式匹配.md

@@ -0,0 +1,65 @@
+---
+{
+  "title": "正则表达式匹配",
+}
+---
+
+## 题目
+
+请实现一个函数用来匹配包括'.'和'*'的正则表达式。
+模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。
+例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配。
+
+## 思路
+
+当模式中的第二个字符不是“*”时：
+- 1、如果字符串第一个字符和模式中的第一个字符相匹配，那么字符串和模式都后移一个字符，然后匹配剩余的。
+- 2、如果 字符串第一个字符和模式中的第一个字符相不匹配，直接返回false。
+       
+而当模式中的第二个字符是“*”时：
+- 如果字符串第一个字符跟模式第一个字符不匹配，则模式后移2个字符，继续匹配。
+      
+如果字符串第一个字符跟模式第一个字符匹配，可以有3种匹配方式：
+- 1、模式后移2字符，相当于x*被忽略；
+- 2、字符串后移1字符，模式后移2字符；
+- 3、字符串后移1字符，模式不变，即继续匹配字符下一位，因为*可以匹配多位；
+
+## 代码
+
+```js
+    function match(s, pattern) {
+      if (s == undefined || pattern == undefined) {
+        return false;
+      }
+      return matchStr(s, pattern, 0, 0);
+    }
+
+    function matchStr(s, pattern, sIndex, patternIndex) {
+      if (sIndex === s.length && patternIndex === pattern.length) {
+        return true;
+      }
+      if (sIndex !== s.length && patternIndex === pattern.length) {
+        return false;
+      }
+      if (patternIndex + 1 < pattern.length && pattern[patternIndex + 1] === '*') {
+        if (sIndex < s.length && (s[sIndex] === pattern[patternIndex] || pattern[patternIndex] === '.')) {
+          return matchStr(s, pattern, sIndex, patternIndex + 2) ||
+            matchStr(s, pattern, sIndex + 1, patternIndex + 2) ||
+            matchStr(s, pattern, sIndex + 1, patternIndex);
+        } else {
+          return matchStr(s, pattern, sIndex, patternIndex + 2)
+        }
+      }
+      if (sIndex < s.length && (s[sIndex] === pattern[patternIndex] || pattern[patternIndex] === '.')) {
+        return matchStr(s, pattern, sIndex + 1, patternIndex + 1)
+      }
+      return false;
+    }
+```
+
+## 考察点
+
+- 字符串
+- 正则表达式
+- 考虑问题的全面性
+- 程序的完整性