feat：数据结之字符串

docs/.vuepress/config.js

@@ -149,11 +149,12 @@ module.exports = {
               //   ]
               // },
               {
-                title: "算法",
+                title: "数据结构与算法",
                 collapsable: false,
                 children: [
-                  ["algorithm/",'解题思路'],
                   ["algorithm/complexity",'复杂度'],
+                  ["algorithm/dataStructure",'数据结构'],
+                  ["algorithm/thinking",'解题思路'],
                   ["algorithm/sort",'排序算法专题'],
                   ["algorithm/base",'真题'],
                 ]

docs/algorithm/base.md

@@ -1,5 +1,5 @@
 
-  ## 3.1 遍历链表节点
+  ## 4.1 遍历链表节点
   链表：在React中的Fiber中采用链表树的数据结构来解决主线程阻塞的问题，我们一起来试着遍历一个简单的链表结构试试
 
   ####  :tomato: 案例：遍历链表节点并对每个节点的value值求和
@@ -64,7 +64,7 @@
         traversal(LinkedList, current => (num += current));
   ```
 
-  ## 3.2 Floyd判圈算法
+  ## 4.2 Floyd判圈算法
   含义： Floyd判圈算法(Floyd Cycle Detection Algorithm)，又称龟兔赛跑算法(Tortoise and Hare Algorithm)，是一个可以在有限状态机、迭代函数或者 链表上判断是否存在环，求出该环的起点与长度的算法。
     在图和树的数据结构在具体使用中，可能会出现循环依赖的情况，如何自动判断，是否存在循环，可以使用Floyd判圈算法
 
@@ -144,7 +144,7 @@
     };
 
   ```
-  ## 3.3 字符串算法(最长公共子序列)
+  ## 4.3 字符串算法(最长公共子序列)
 
   ####  :tomato: 字符串算法？
      
@@ -232,7 +232,7 @@
     console.log(count) //3
   ```
 
-## 3.4  莱温斯坦距离问题
+## 4.4  莱温斯坦距离问题
 
  含义：莱文斯坦距离，又称Levenshtein距离，是编辑距离的一种，指两个字串之间，由一个转成另一个所需最少编辑操作次数
 

docs/algorithm/complexity.md

@@ -1,6 +1,6 @@
 我们对一个算法进行评价，一般有 2 个重要依据-时间复杂度和空间复杂度。
 
-## 2.1 时间复杂度
+## 1.1 时间复杂度
 
 | 名称 | 运行时间 T(n) | 时间举例 |   算法举例   |
 | :--: | :-----------: | :------: | :----------: |
@@ -55,7 +55,7 @@ for (leti = 1; i <= n; i *= 2) {
 假设 i 在 i=i\*2 的规则递增了 x 次之后，i<=n 开始不成立；那么我们可以推算出下面一个数学方程式:
 
 ```js
-2 ^ (x >= n)
+2 ^ x >= n
 ```
 
 x 解出来，就是大于等于以 2 为底 n 的对数。
@@ -90,7 +90,7 @@ functionfibonacci(n){
 假如n=5，那么递归的的时间复杂度该怎么算？
 
 在 n 层的完全二叉树中，节点的总数为 2n − 1 ，所以得到 F(n) 中递归数目的上限为 2n − 1 。因此我们可以大概估出 F(n) 的时间复杂度为 O(2^n)。在斐波那契中有大量重复的计算，我们可以把已经计算过的存起来，同样的计算再取出来。
-## 2.2 空间复杂度
+## 1.2 空间复杂度
 
 空间复杂度是对算法运行过程中临时占用空间大小的度量，一个算法所需的存储空间用 f (n) 表 示，可得出 S(n) = O(f(n)) ，其中 n 为问题的规模， S(n) 表示空间复杂度。通常用 S(n) 来定义。
 
@@ -138,14 +138,14 @@ for (let i = 0; i < n; i++) {
 }
 ```
 
-上面占用空间的变量：`arr、i 、n`；可以看出 arr 并不是一个一成不变的数组，内层循环会执行 n\*n 次，因此空间复杂度为 O(n^2。
+上面占用空间的变量：`arr、i 、n`；可以看出 arr 并不是一个一成不变的数组，内层循环会执行 n\*n 次，因此空间复杂度为 O(n^2)。
 
-### 时间空间相互转换
+
+## 1.3 总结
+#### 时间空间相互转换
 
 对于一个算法来说，它的时间复杂度和空间复杂度往往是相互影响的。
 那我们熟悉的 Chrome 来说，流畅性方面比其他厂商好了多人，但是占用的内存空间略大。
 当追求一个较好的时间复杂度时，可能需要消耗更多的储存空间。 反之，如果追求较好的空间复杂 度，算法执行的时间可能就会变长。
 
-### 总结
-
 常见的复杂度不多，从低到高排列就这么几个: O(1) 、 O(log(n)) 、 O(n) 、 O(n^2) 、O(2^n)。

docs/algorithm/dataStructure.md

@@ -0,0 +1,90 @@
+javascript常用的数据结构：
+
+- 字符串
+- 数组
+- 栈
+- 队列
+- 链表
+- 树
+
+## 2.1 字符串
+
+字符串是由零个和多个字符组成的有序序列，是javascript最基础的数据结构，也是学习编程的基础。
+
+### 2.1.1 翻转整数
+
+示例：
+```bash
+输入: 123
+输出: 321
+
+输入: -123
+输出: -321
+```
+
+```js
+function reverse(params) {
+  if(typeof params !== 'number') return
+
+  const value = params>0? 
+              String(params).split('').reverse().join(''): 
+              String(params).slice(1).split('').reverse().join('')
+  return value
+}
+```
+#### 复杂度分析
+
+- 时间复杂度 O(n)
+
+reverse 函数时间复杂度为 O(n)，n为整数长度,最好的情况为O(1)。
+
+- 空间复杂度 O(n)
+
+代码中创建临时对value象， n为整数长度，因此空间复杂度为 O(n),最好的情况为O(1)。
+
+### 2.1.1 反转字符串
+
+示例：
+```bash
+输入: china
+输出: anihc
+```
+
+#### 方法1
+
+```js
+function reverse(params) {
+  if(typeof params !== 'number') return
+  // 反转字符串
+  return  params.split('').reverse().join('')
+}
+```
+
+#### 方法2 首尾替换法
+
+如果在面试过程中回答出第一种可能不是面试官想要的，就像排序回答sort类似。
+
+```js
+function reverse(str) {
+ const params=str.split('')
+ for(let i=0;i<params.length/2 ;i++){
+    [params[i],params[params.length-i-1]]= [params[params.length-i-1],params[i]]
+ }
+ return params.join('')
+}
+```
+
+#### 复杂度分析
+
+时间复杂度: O(n) 
+
+空间复杂度: O(1)
+
+reverse中没有新开辟的内存空间
+
+
+
+
+
+
+

docs/algorithm/index.md → docs/algorithm/thinking.md

@@ -1,7 +1,3 @@
-## 1.1 前言
-
-我们在大部分业务中接触不到算法，觉得没必要看；有些人为了面试会刷一些算法题，刷完可能过一段时间就会忘掉；我常常在想我们工作中哪里会用的到，我该怎样去学好算法；直到我做一个后台项目，其实对某些大量的数据处理其实可以用到算法的，业务场景的千变万花，刷的那些题如何应用到业务中也是值得思考的问题；学好算法的第一步，我觉得应该是解题思路。
-
 ### 1. 回溯算法
 
 回溯算法是一种尝试算法，按选优条件进行搜索；主要是在搜索尝试过程中找问题的解，当发现不满足条件时，就返回，尝试别的路径。