diff --git a/.editorconfig b/.editorconfig new file mode 100755 index 0000000..6e87a00 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,13 @@ +# Editor configuration, see http://editorconfig.org +root = true + +[*] +charset = utf-8 +indent_style = space +indent_size = 2 +insert_final_newline = true +trim_trailing_whitespace = true + +[*.md] +max_line_length = off +trim_trailing_whitespace = false diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml deleted file mode 100644 index 73dd303..0000000 --- a/.github/workflows/deploy.yml +++ /dev/null @@ -1,36 +0,0 @@ -name: deploy - -on: - push: - branches: - - master - -jobs: - deploy: - runs-on: ubuntu-latest - steps: - - name: Checkout - uses: actions/checkout@v3 - with: - fetch-depth: 0 - - - name: Setup Node.js v18.x - uses: actions/setup-node@v1 - with: - node-version: "18.x" - - - name: Install - run: npm install - - - name: Build - run: npm run build - - - name: Deploy - uses: peaceiris/actions-gh-pages@v3 - with: - publish_dir: ./dist - publish_branch: gh-pages - github_token: ${{ secrets.GH_PAGES_DEPLOY }} - user_name: ${{ secrets.MY_USER_NAME }} - user_email: ${{ secrets.MY_USER_EMAIL }} - commit_message: deploy docs site diff --git a/.gitignore b/.gitignore index 00a2add..cb90aec 100644 --- a/.gitignore +++ b/.gitignore @@ -1,17 +1,15 @@ -# See http://help.github.com/ignore-files/ for more about ignoring files. - -# compiled output -/src/.vitepress/dist -/src/.vitepress/cache +.DS_Store +Thumbs.db +db.json +*.log +node_modules/ dist -dist-ssr -/tmp -/out-tsc +.deploy*/ # dependencies -node_modules +# dependencies +/node_modules yarn.lock -package-lock.json # IDEs and editors /.idea @@ -42,10 +40,3 @@ testem.log /e2e/src/*.js /e2e/src/*.map /cypress/screenshots - -# System Files -.DS_Store -Thumbs.db - -# Other -*.local diff --git a/.prettierrc b/.prettierrc new file mode 100755 index 0000000..085916e --- /dev/null +++ b/.prettierrc @@ -0,0 +1,9 @@ +{ + "useTabs": false, + "printWidth": 80, + "tabWidth": 2, + "singleQuote": true, + "trailingComma": "none", + "jsxBracketSameLine": false, + "parser": "babylon" +} diff --git a/README.md b/README.md index 929746f..77a3ddc 100644 --- a/README.md +++ b/README.md @@ -1,47 +1,94 @@ # JavaScript 数据结构与算法 -本仓库的[文档](https://data-structure-and-algorithm.xpoet.cn)根据哔哩哔哩[《JavaScript 数据结构与算法》](https://www.bilibili.com/video/BV1x7411L7Q7)视频内容整理而成的学习笔记,视频教程讲得特别好,配合本仓库的文档和测试代码,学习效果更佳。 +本仓库内容根据哔哩哔哩 [《JavaScript 数据结构与算法》](https://www.bilibili.com/video/BV1x7411L7Q7?p=1) 视频整理的学习笔记,视频教程讲的特别好,配合本仓库的代码测试环境来练习,学习效果更佳,欢迎同学们 Star 和 Fork。 -推荐大家按照目录结构的顺序来学习,由浅入深,循序渐进,轻松搞定数据结构和算法。 +推荐大家按照目录顺序来学习,由浅入深,循序渐进,轻松搞定数据结构和算法。 -## 在线预览 +> 重点要掌握数据结构与算法的思想和原理,使用哪种编程语言区别不大。 -**https://data-structure-and-algorithm.xpoet.cn** +## 交流群 -## 学习交流 +- 扫描下方二维码,加入微信交流群,欢迎小伙伴们畅所欲言,包括但不限于前端技术问题,大家一起成长~ -作者组建了学习氛围特别好的前端技术交流群,欢迎同学们一起来交流吐槽。由于群人数较多,需要添加作者才能邀请进群。 + -> 添加微信时请备注来意,以便可以及时处理。 +- 如果上面的二维码失效,可关注公众号《前端鼓励师》,添加作者微信,再由作者拉你进群~ -![image](https://xpoet.cn/images/fp/fp-slogan.webp) + -## 数据结构 +## 文档目录 -- [数组](https://data-structure-and-algorithm.xpoet.cn/data-structure/Array.html) -- [栈](https://data-structure-and-algorithm.xpoet.cn/data-structure/Stack.html) -- [队列](https://data-structure-and-algorithm.xpoet.cn/data-structure/Queue.html) -- [优先队列](https://data-structure-and-algorithm.xpoet.cn/data-structure/PriorityQueue.html) -- [单向链表](https://data-structure-and-algorithm.xpoet.cn/data-structure/LinkedList.html) -- [双向链表](https://data-structure-and-algorithm.xpoet.cn/data-structure/DoubleLinkedList.html) -- [集合](https://data-structure-and-algorithm.xpoet.cn/data-structure/Set.html) -- [字典](https://data-structure-and-algorithm.xpoet.cn/data-structure/Map.html) -- [哈希表](https://data-structure-and-algorithm.xpoet.cn/data-structure/HashTable.html) -- [树](https://data-structure-and-algorithm.xpoet.cn/data-structure/Tree.html) -- [二叉树](https://data-structure-and-algorithm.xpoet.cn/data-structure/BinaryTree.html) -- [二叉搜索树](https://data-structure-and-algorithm.xpoet.cn/data-structure/BinarySearchTree.html) -- [图](https://data-structure-and-algorithm.xpoet.cn/data-structure/Graph.html) +- [JavaScript 数据结构与算法(一)前言](assets/doc/01_JavaScript数据结构与算法(一)前言.md) +- [JavaScript 数据结构与算法(二)数组](assets/doc/02_JavaScript数据结构与算法(二)数组.md) +- [JavaScript 数据结构与算法(三)栈](assets/doc/03_JavaScript数据结构与算法(三)栈.md) +- [JavaScript 数据结构与算法(四)队列](assets/doc/04_JavaScript数据结构与算法(四)队列.md) +- [JavaScript 数据结构与算法(五)优先队列](assets/doc/05_JavaScript数据结构与算法(五)优先队列.md) +- [JavaScript 数据结构与算法(六)单向链表](assets/doc/06_JavaScript数据结构与算法(六)单向链表.md) +- [JavaScript 数据结构与算法(七)双向链表](assets/doc/07_JavaScript数据结构与算法(七)双向链表.md) +- [JavaScript 数据结构与算法(八)集合](assets/doc/08_JavaScript数据结构与算法(八)集合.md) +- [JavaScript 数据结构与算法(九)字典](assets/doc/09_JavaScript数据结构与算法(九)字典.md) +- [JavaScript 数据结构与算法(十)哈希表](assets/doc/10_JavaScript数据结构与算法(十)哈希表.md) +- [JavaScript 数据结构与算法(十一)树](assets/doc/11_JavaScript数据结构与算法(十一)树.md) +- [JavaScript 数据结构与算法(十二)二叉树](assets/doc/12_JavaScript数据结构与算法(十二)二叉树.md) +- [JavaScript 数据结构与算法(十三)二叉搜索树](assets/doc/13_JavaScript数据结构与算法(十三)二叉搜索树.md) +- [JavaScript 数据结构与算法(十四)图](assets/doc/14_JavaScript数据结构与算法(十四)图.md) -## 算法 +## 代码目录 -- [排序算法](https://data-structure-and-algorithm.xpoet.cn/algorithm/sort.html) -- [搜索算法](https://data-structure-and-algorithm.xpoet.cn/algorithm/search.html) -- [算法设计思想](https://data-structure-and-algorithm.xpoet.cn/algorithm/idea.html) -- [经典算法题](https://data-structure-and-algorithm.xpoet.cn/algorithm/classic.html) +- [栈的封装](src/Stack/stack.js) +- [队列的封装](src/Queue/queue.js) +- [优先队列的封装](src/PriorityQueue/priorityQueue.js) +- [单向链表的封装](src/LinkedList/linkedList.js) +- [双向链表的封装](src/DoublyLinkedList/doublyLinkedList.js) +- [集合的封装](src/Set/set.js) +- [字典的封装](src/Map/map.js) +- [哈希表的封装](src/HashTable/hashTable.js) +- [二叉搜索树的封装](src/Tree/tree.js) +- [图的封装](src/Graph/graph.js) -## 测试代码 +## 测试环境 -数据结构的测试代码存放在 [src/docs/public/ data-structure](https://github.com/XPoet/js-data-structure-and-algorithm/tree/master/src/docs/public/data-structure) 目录。 +### 安装依赖 +```bash +npm install +``` +### 启动服务 +```bash +npm run start +``` +开启**测试环境**的服务后,可在 `src/index.js` 选择要测试的代码,查看具体值输出。 +比如:我要测试**栈**,把 `// import './Stack'` 的注释去掉,要测试哪个就去掉哪个的注释。 +```js +// 导入栈结构的封装及测试代码 +// import './Stack' + +// 导入队列结构的封装及测试代码 +// import './Queue' + +// 导入优先队列结构的封装及测试代码 +// import './PriorityQueue' + +// 导入单向链表结构的封装及测试代码 +// import './LinkedList' + +// 导入双向链表结构的封装及测试代码 +// import './DoublyLinkedList' + +// 导入集合结构的封装及测试代码 +// import './Set' + +// 导入字典结构的封装及测试代码 +// import './Map' + +// 导入哈希表结构的封装及测试代码 +// import './HashTable'; + +// 导入树结构的封装及测试代码 +// import './Tree'; + +// 导入图结构的封装及测试代码 +// import './Graph'; +``` diff --git "a/assets/doc/01_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円270円200円357円274円211円345円211円215円350円250円200円.md" "b/assets/doc/01_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円270円200円357円274円211円345円211円215円350円250円200円.md" new file mode 100644 index 0000000..8076840 --- /dev/null +++ "b/assets/doc/01_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円270円200円357円274円211円345円211円215円350円250円200円.md" @@ -0,0 +1,100 @@ +# JavaScript 数据结构与算法(一)前言 + +## 什么是数据结构? + +### 数据结构的定义 + +- 官方定义 + + 无 + +- 民间定义 + + - "数据结构是数据对象,以及存在于该对象的实例和组成实例的数据元素之间的各种联系。这些联系可以通过定义相关的函数来给出。" --- 《数据结构、算法与应用》 + - "数据结构是 ADT(抽象数据类型 Abstract Data Type)的物理实现。" --- 《数据结构与算法分析》 + - "数据结构(data structure)是计算机中存储、组织数据的方式。通常情况下,精心选择的数据结构可以带来最优效率的算法。" ---中文维基百科 + +- 从自己角度认识 + + 在计算机中,存储和组织数据的方式。 + +### 数据结构在生活中应用 + +我们知道,计算机中数据量非常庞大,如何以高效的方式组织和存储呢? + +例如:一个庞大的图书馆中存放了大量的书籍,我们不仅仅要把书放进入,还应该在合适的时候能够取出来。 + +图书摆放要使得两个相关操作方便实现: + +- 操作 1:新书怎么插入? +- 操作 2:怎么找到某本指定的书? + +图书各种摆放方式: + +- 方法 1:随便放 + + - 操作 1:哪里有空位放哪里。 + - 操作 2:找某本书,累死。 + +- 方法 2:按照书名的拼音字母顺序排放 + + - 操作 1:新进一本《阿 Q 正传》, 按照字母顺序找到位置,插入。 + - 操作 2:二分查找法。 + +- 方法 3:把书架划分成几块区域,按照类别存放,类别中按照字母顺序 + + - 操作 1:先定类别,二分查找确定位置,移出空位。 + - 操作 2:先定类别,再二分查找。 + +结论: + +- 解决问题方法的效率,根据数据的组织方式有关。 +- 计算机中存储的数据量相对于图书馆的书籍来说数据量更大,数据更加多。 +- 以什么样的方式,来存储和组织我们的数据才能在使用数据时更加方便呢? +- 这就是数据结构需要考虑的问题。 + +### 常见的数据结构 + +- 数组(Aarray) +- 栈(Stack) +- 链表(Linked List) +- 图(Graph) +- 散列表(Hash) +- 队列(Queue) +- 树(Tree) +- 堆(Heap) + +> 注意:数据结构与算法与语言无关,常见的编程语言都有**直接或间接**的使用上述常见的数据结构。 + +## 什么是算法? + +### 算法(Algorithm)的定义 + +- 一个有限指令集,每条指令的描述不依赖于语言。 +- 接收一些输入(有些情况下不需要输入)。 +- 产生输出。 +- 一定在有限步骤之后终止。 + +### 算法通俗理解 + +- Algorithm 这个单词本意就是解决问题的办法/步骤逻辑。 +- 数据结构的实现,离不开算法。 + +### 算法案例 + +假如上海和杭州之间有一条高架线,高架线长度是 1,000,000 米,有一天高架线中有其中一米出现了故障,请你想出一种算法,可以快速定位到处问题的地方。 + +- 线性查找 + + - 从上海的起点开始一米一米的排查,最终一定能找到出问题的线段。 + - 但是如果线段在另一头,我们需要排查 1,000,000 次,这是最坏的情况,平均需要 500,000 次。 + +- 二分查找 + + - 从中间位置开始排查,看一下问题出在上海到中间位置,还是中间到杭州的位置。 + - 查找对应的问题后,再从中间位置分开,重新锁定一般的路程。 + - 最坏的情况,需要多少次可以排查完呢? 最坏的情况是 20 次就可以找到出问题的地方。 + - 怎么计算出来的呢? log(1000000, 2),以 2 位底,1000000 的对数 ≈ 20。 + +结论: +你会发现,解决问题的办法有很多,但是好的算法对比于差的算法,效率天壤之别。 diff --git "a/assets/doc/02_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円272円214円357円274円211円346円225円260円347円273円204円.md" "b/assets/doc/02_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円272円214円357円274円211円346円225円260円347円273円204円.md" new file mode 100644 index 0000000..e8478e2 --- /dev/null +++ "b/assets/doc/02_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円272円214円357円274円211円346円225円260円347円273円204円.md" @@ -0,0 +1,79 @@ +# JavaScript 数据结构与算法(二)数组 + +几乎所有的编程语言都原生支持数组类型,因为数组是最简单的内存数据结构。 +数组通常情况下用于存储一系列同一种数据类型的值。 +但在 JavaScript 里,数组中可以保存不同类型的值。但我们还是要遵守最佳实践,别这么做(大多数语言都没这个能力)。 + +## 创建和初始化数组 + +- `new Array()` + + ```js + const daysOfWeek = new Array( + "Sunday", + "Monday", + "Tuesday", + "Wednesday", + "Thursday", + "Friday", + "Saturday" + ); + ``` + +- `[]` + ```js + const daysOfWeek = [ + "Sunday", + "Monday", + "Tuesday", + "Wednesday", + "Thursday", + "Friday", + "Saturday", + ]; + ``` + +## 数组常见操作 + +### 添加元素 + +- 添加一个元素到数组的最后位置 `array.push(item)` +- 在数组首位插入一个元素 `array.unshift(item)` +- 在指定索引位置插入元素 `array.splice(index, 0, item)` +> splice() 第二个参数为 0 时,表示插入数据。 + ```js + let myArray = [1, 2, 3]; + // 在 索引 0 的位置,插入 A + myArray.splice(0, 0, "A"); + console.log(myArray); //--> ['A', 1, 2, 3] + ``` + +### 删除元素 + +- 删除数组最后的元素 `array.pop(item)` +- 删除数组首位的元素 `array.shift(item)` +- 删除指定索引位置的元素 `array.splice(start, number)` + 例如: + ```js + let myArray2 = [1, 2, 3, 4, 5]; + // 删除索引 4 位置起,2 个元素 + myArray2.splice(4, 2); + console.log(myArray2); //--> [1, 2, 3] + ``` + +### 修改元素 + +- 修改指定索引位置的元素 `array.splice(index, 1, item)` + ```js + let myArray3 = [1, 2, 3, 4, 5, 6]; + // 修改 索引 1 的位置的元素为 AA + myArray2.splice(1, 1, "AA"); + console.log(myArray3); //--> [1, "AA", 3, 4, 5, 6] + ``` +- 修改指定索引位置的几个元素 `array.splice(index, number, item)` + ```js + let myArray4 = [1, 2, 3, 4, 5, 6, 7]; + // 在 索引 2 的位置起,修改两个元素为 AA BB + myArray2.splice(2, 2, "AA", "BB"); + console.log(myArray3); //--> [1, 2, "AA", "BB", 5, 6, 7] + ``` diff --git a/src/docs/data-structure/Stack.md "b/assets/doc/03_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円270円211円357円274円211円346円240円210円.md" similarity index 75% rename from src/docs/data-structure/Stack.md rename to "assets/doc/03_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円270円211円357円274円211円346円240円210円.md" index 5de00d8..e48df7b 100644 --- a/src/docs/data-structure/Stack.md +++ "b/assets/doc/03_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円270円211円357円274円211円346円240円210円.md" @@ -1,18 +1,20 @@ -# 栈 +## JavaScript 数据结构与算法(三)栈 -数组是一个线性结构,可以在数组的任意位置插入和删除元素。但是有时候,我们为了实现某些功能,必须对这种任意性加以限制。栈和队列就是比较常见的受限的线性结构。 +数组是一个线性结构,并且可以在数组的任意位置插入和删除元素。 +但是有时候,我们为了实现某些功能,必须对这种任意性加以限制。 +栈和队列就是比较常见的受限的线性结构。 ## 什么是栈 -栈(stack)是一种运算受限的线性表。 +栈(stack)是一种运算受限的线性表: -- `LIFO(last in first out)`表示就是后进入的元素,第一个弹出栈空间。 -> 类似于自动餐托盘,最后放上的托盘,往往先被拿出去使用。 -- 仅允许在表的一端进行插入和删除运算。这一端被称为栈顶,相对地,把另一端称为栈底。 -- 向一个栈插入新元素又称作**进栈**、**入栈**或**压栈**,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素; -- 从一个栈删除元素又称作**出栈**或**退栈**,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素。 +- `LIFO(last in first out)`表示就是后进入的元素,第一个弹出栈空间。类似于自动餐托盘,最后放上的托盘,往往先把拿出去使用。 +- 其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶,相对地,把另一端称为栈底。 +- 向一个栈插入新元素又称作进栈、入栈或压栈,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素; +- 从一个栈删除元素又称作出栈或退栈,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素。 -![image](../public/images/data-structure/img-01.png) +如下图所示: +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.71xt32okr3k0.png) 栈的特点:**先进后出,后进先出**。 @@ -22,16 +24,16 @@ 即 A 函数中调用 B,B 调用 C,C 调用 D;在 A 执行的过程中会将 A 压入栈,随后 B 执行时 B 也被压入栈,函数 C 和 D 执行时也会被压入栈。所以当前栈的顺序为:A->B->C->D(栈顶);函数 D 执行完之后,会弹出栈被释放,弹出栈的顺序为 D->C->B->A; - 递归: - 为什么没有停止条件的递归会造成栈溢出?比如函数 A 为递归函数,不断地调用自己(因为函数还没有执行完,不会把函数弹出栈),不停地把相同的函数 A 压入栈,最后造成栈溢出(stack overflow)。 + 为什么没有停止条件的递归会造成栈溢出?比如函数 A 为递归函数,不断地调用自己(因为函数还没有执行完,不会把函数弹出栈),不停地把相同的函数 A 压入栈,最后造成栈溢出(Queue Overfloat)。 ## 练习 题目:有 6 个元素 6,5,4,3,2,1 按顺序进栈,问下列哪一个不是合法的出栈顺序? -- A: 5 4 3 6 1 2 (√) -- B: 4 5 3 2 1 6 (√) -- C: 3 4 6 5 2 1 (×ばつ) -- D: 2 3 4 1 5 6 (√) +- A:5 4 3 6 1 2 (√) +- B:4 5 3 2 1 6 (√) +- C:3 4 6 5 2 1 (×ばつ) +- D:2 3 4 1 5 6 (√) 题目所说的按顺序进栈指的不是一次性全部进栈,而是有进有出,进栈顺序为 6 -> 5 -> 4 -> 3 -> 2 -> 1。 @@ -57,7 +59,7 @@ ```js // 栈结构的封装 -class Stack { +class Map { constructor() { this.items = []; } @@ -131,8 +133,8 @@ console.log(stack.toString()); //--> 1 2 ```js function dec2bin(dec) { - // new 一个 Stack,保存余数 - const stack = new Stack(); + // new 一个 Map,保存余数 + const stack = new Map(); // 当不确定循环次数时,使用 while 循环 while (dec> 0) { diff --git a/src/docs/data-structure/Queue.md "b/assets/doc/04_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円233円233円357円274円211円351円230円237円345円210円227円.md" similarity index 90% rename from src/docs/data-structure/Queue.md rename to "assets/doc/04_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円233円233円357円274円211円351円230円237円345円210円227円.md" index 3f40965..f25405e 100644 --- a/src/docs/data-structure/Queue.md +++ "b/assets/doc/04_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円233円233円357円274円211円351円230円237円345円210円227円.md" @@ -1,10 +1,10 @@ -# 队列 +# JavaScript 数据结构与算法(四)队列 ## 认识队列 -队列(Queue)是一种运算受限的线性表,特点:先进先出 (FIFO:First In First Out)。 +队列(Queue)是一种运算受限的线性表,特点:先进先出。(FIFO:First In First Out) -受限之处: +**受限之处:** - 只允许在表的前端(front)进行删除操作。 - 只允许在表的后端(rear)进行插入操作。 @@ -14,11 +14,11 @@ - 排队,比如在电影院,商场,甚至是厕所排队。 - 优先排队的人,优先处理。 (买票、结账、WC)。 -![image](../public/images/data-structure/img-02.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.5mmiw2kdwbs0.png) ### 队列图解 -![image](../public/images/data-structure/img-03.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.mq92bw3am0g.png) ### 队列在程序中的应用 @@ -37,7 +37,7 @@ - `enqueue(element)` 向队列尾部添加一个(或多个)新的项。 - `dequeue()` 移除队列的第一(即排在队列最前面的)项,并返回被移除的元素。 - `front()` 返回队列中的第一个元素——最先被添加,也将是最先被移除的元素。队列不做任何变动(不移除元素,只返回元素信息与 Map 类的 peek 方法非常类似)。 -- `isEmpty()` 如果队列中不包含任何元素,返回 `true`,否则返回 `false`。 +- `isEmpty()` 如果队列中不包含任何元素,返回 true,否则返回 false。 - `size()` 返回队列包含的元素个数,与数组的 length 属性类似。 - `toString()` 将队列中的内容,转成字符串形式。 diff --git a/src/docs/data-structure/PriorityQueue.md "b/assets/doc/05_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円272円224円357円274円211円344円274円230円345円205円210円351円230円237円345円210円227円.md" similarity index 94% rename from src/docs/data-structure/PriorityQueue.md rename to "assets/doc/05_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円272円224円357円274円211円344円274円230円345円205円210円351円230円237円345円210円227円.md" index 26cb423..f09f572 100644 --- a/src/docs/data-structure/PriorityQueue.md +++ "b/assets/doc/05_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円272円224円357円274円211円344円274円230円345円205円210円351円230円237円345円210円227円.md" @@ -1,4 +1,4 @@ -# 优先队列 +# JavaScript 数据结构与算法(五)优先队列 ## 场景 @@ -140,4 +140,4 @@ console.log(priorityQueue.toString()); //--> B-15 E-18 D-20 ## 数组、栈和队列图解 -![image](../public/images/data-structure/img-04.png) +![数组、栈和队列图解](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.64kg5ej56vk0.png) diff --git a/src/docs/data-structure/LinkedList.md "b/assets/doc/06_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円205円255円357円274円211円345円215円225円345円220円221円351円223円276円350円241円250円.md" similarity index 86% rename from src/docs/data-structure/LinkedList.md rename to "assets/doc/06_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円205円255円357円274円211円345円215円225円345円220円221円351円223円276円350円241円250円.md" index f36aeee..546779b 100644 --- a/src/docs/data-structure/LinkedList.md +++ "b/assets/doc/06_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円205円255円357円274円211円345円215円225円345円220円221円351円223円276円350円241円250円.md" @@ -1,10 +1,12 @@ -# 单向链表 +# JavaScript 数据结构与算法(六)单向链表 -## 链表和数组 +## 认识链表 + +### 链表和数组 链表和数组一样,可以用于存储一系列的元素,但是链表和数组的实现机制完全不同。 -### 数组 +#### 数组 - 存储多个元素,数组(或列表)可能是最常用的数据结构。 @@ -12,17 +14,17 @@ - 数组缺点: - 数组的创建需要申请一段连续的内存空间 (一整块内存),并且大小是固定的,当前数组不能满足容量需求时,需要扩容。 (一般情况下是申请一个更大的数组,比如 2 倍,然后将原数组中的元素复制过去) + 数组的创建需要申请一段连续的内存空间(一整块内存),并且大小是固定的,当前数组不能满足容量需求时,需要扩容。 (一般情况下是申请一个更大的数组,比如 2 倍,然后将原数组中的元素复制过去) 在数组开头或中间位置插入数据的成本很高,需要进行大量元素的位移。 -### 链表 +#### 链表 - 存储多个元素,另外一个选择就是使用链表。 - 不同于数组,链表中的元素在内存中不必是连续的空间。 -- 链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用 (有些语言称为指针) 组成。 +- 链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用(有些语言称为指针)组成。 - 链表优点: @@ -30,7 +32,7 @@ 链表不必在创建时就确定大小,并且大小可以无限延伸下去。 - 链表在插入和删除数据时,时间复杂度可以达到 **O(1)**,相对数组效率高很多。 + 链表在插入和删除数据时,时间复杂度可以达到 O(1),相对数组效率高很多。 - 链表缺点: @@ -46,30 +48,30 @@ - 链表的火车结构 - ![img](../public/images/data-structure/img-05.png) + ![链表的火车结构](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.27xtn3c52zwg.png) - 链表的数据结构 - head 属性指向链表的第一个节点。 + head 属性指向链表的第一个节点。 链表中的最后一个节点指向 `null`。 当链表中一个节点也没有的时候,head 直接指向 `null`。 - ![img.png](../public/images/data-structure/img-06.png) + ![链表的数据结构](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.37j1by46a120.png) - 给火车加上数据后的结构 - ![img.png](../public/images/data-structure/img-07.png) + ![给火车加上数据后的结构](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.664djiie2t80.png) ### 链表中的常见操作 - `append(element)` 向链表尾部添加一个新的项。 - `insert(position, element)` 向链表的特定位置插入一个新的项。 - `get(position)` 获取对应位置的元素。 -- `indexOf(element)` 返回元素在链表中的索引。如果链表中没有该元素就返回 -1。 +- `indexOf(element)` 返回元素在链表中的索引。如果链表中没有该元素就返回-1。 - `update(position, element)` 修改某个位置的元素。 - `removeAt(position)` 从链表的特定位置移除一项。 - `remove(element)` 从链表中移除一项。 -- `isEmpty()` 如果链表中不包含任何元素,返回 `trun`,如果链表长度大于 0 则返回 `false`。 +- `isEmpty()` 如果链表中不包含任何元素,返回 trun,如果链表长度大于 0 则返回 false。 - `size()` 返回链表包含的元素个数,与数组的 length 属性类似。 - `toString()` 由于链表项使用了 Node 类,就需要重写继承自 JavaScript 对象默认的 toString 方法,让其只输出元素的值。 @@ -100,7 +102,7 @@ class LinkedList { #### 实现 append() 方法 -代码实现: +##### 代码实现 ```js // append() 往链表尾部追加数据 @@ -116,35 +118,36 @@ append(data) { this.head = newNode; } else { - // 链表长度大于 0 时,在最后面添加新节点 - let currentNode = this.head; + // 链表长度大于 0 时,在最后面添加新节点 + let currentNode = this.head; - // 当 currentNode.next 不为空时, - // 循序依次找最后一个节点,即节点的 next 为 null 时 - while (currentNode.next !== null) { - currentNode = currentNode.next; - } + // 当 currentNode.next 不为空时, + // 循序依次找最后一个节点,即节点的 next 为 null 时 + while (currentNode.next !== null) { + currentNode = currentNode.next; + } - // 最后一个节点的 next 指向新节点 - currentNode.next = newNode; + // 最后一个节点的 next 指向新节点 + currentNode.next = newNode; } // 3、追加完新节点后,链表长度 + 1 this.length++; + } ``` -过程图解: +##### 过程图解 - 首先让 `currentNode` 指向第一个节点。 - ![img.png](../public/images/data-structure/img-08.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.5iskrdf4nu40.png) - 通过 `while` 循环使 `currentNode` 指向最后一个节点,最后通过 `currentNode.next = newNode`,让最后一个节点指向新节点 `newNode`。 - ![img.png](../public/images/data-structure/img-09.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4mw3bx5g80m0.png) -代码测试: +##### 代码测试 ```js const linkedList = new LinkedList(); @@ -155,11 +158,11 @@ linkedList.append("C"); console.log(linkedList); ``` -![img.png](../public/images/data-structure/img-10.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.6kx4qbq8e5c.png) #### 实现 toString() 方法 -代码实现: +##### 代码实现 ```js toString() { @@ -176,7 +179,7 @@ toString() { } ``` -代码测试: +##### 代码测试 ```js // 测试 toString 方法 @@ -185,7 +188,7 @@ console.log(linkedList.toString()); //--> AA BB CC #### 实现 insert() 方法 -代码实现: +##### 代码实现 ```js // insert() 在指定位置(position)插入节点 @@ -232,7 +235,7 @@ insert(position, data) { } ``` -代码测试: +##### 代码测试 ```js // 测试 insert 方法 @@ -245,7 +248,7 @@ console.log(linkedList.toString()); //--> 123 AA 456 BB CC 获取指定位置(position)的 data。 -代码实现: +##### 代码实现 ```js getData(position) { @@ -264,7 +267,7 @@ getData(position) { } ``` -代码测试: +##### 代码测试 ```js // 测试 getData 方法 @@ -276,7 +279,7 @@ console.log(linkedList.getData(1)); //--> AA indexOf(data) 返回指定 data 的 index,如果没有,返回 -1。 -代码实现: +##### 代码实现 ```js indexOf(data) { @@ -296,7 +299,7 @@ indexOf(data) { } ``` -代码测试: +##### 代码测试 ```js // 测试 indexOf 方法 @@ -308,7 +311,7 @@ console.log(linkedList.indexOf("ABC")); //--> -1 update(position, data) 修改指定位置节点的 data。 -代码实现: +##### 代码实现 ```js update(position, data) { @@ -330,7 +333,7 @@ update(position, data) { } ``` -代码测试: +##### 代码测试 ```js // 测试 update 方法 @@ -344,7 +347,7 @@ console.log(linkedList.toString()); //--> 12345 54321 456 BB CC removeAt(position) 删除指定位置的节点。 -代码实现: +##### 代码实现 ```js removeAt(position) { @@ -380,7 +383,7 @@ removeAt(position) { } ``` -代码测试: +##### 代码测试 ```js // 测试 removeAt 方法 @@ -392,7 +395,7 @@ console.log(linkedList.toString()); //--> 12345 54321 456 CC remove(data) 删除指定 data 所在的节点。 -代码实现: +##### 代码实现 ```js remove(data) { @@ -400,7 +403,7 @@ remove(data) { } ``` -代码测试: +##### 代码测试 ```js // 测试 remove 方法 @@ -412,7 +415,7 @@ console.log(linkedList.toString()); //--> 12345 54321 456 isEmpty() 判断链表是否为空。 -代码实现: +##### 代码实现 ```js isEmpty() { @@ -420,7 +423,7 @@ isEmpty() { } ``` -代码测试: +##### 代码测试 ```js // 测试 isEmpty 方法 @@ -431,7 +434,7 @@ console.log(linkedList.isEmpty()); //--> false size() 获取链表的长度。 -代码实现: +##### 代码实现 ```js size() { @@ -439,7 +442,7 @@ size() { } ``` -代码测试: +##### 代码测试 ```js // 测试 size 方法 diff --git a/src/docs/data-structure/DoubleLinkedList.md "b/assets/doc/07_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円270円203円357円274円211円345円217円214円345円220円221円351円223円276円350円241円250円.md" similarity index 98% rename from src/docs/data-structure/DoubleLinkedList.md rename to "assets/doc/07_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円270円203円357円274円211円345円217円214円345円220円221円351円223円276円350円241円250円.md" index 9701db5..17ac61a 100644 --- a/src/docs/data-structure/DoubleLinkedList.md +++ "b/assets/doc/07_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円270円203円357円274円211円345円217円214円345円220円221円351円223円276円350円241円250円.md" @@ -1,4 +1,4 @@ -# 双向链表 +# JavaScript 数据结构与算法(七)双向链表 ## 单向链表和双向链表 @@ -6,7 +6,7 @@ - 只能从头遍历到尾或者从尾遍历到头(一般从头到尾)。 - 链表相连的过程是单向的,实现原理是上一个节点中有指向下一个节点的引用。 -- 单向链表有一个比较明显的缺点:可以轻松到达下一个节点,但回到前一个节点很难,在实际开发中,经常会遇到需要回到上一个节点的情况。 +- 单向链表有一个比较明显的缺点:可以轻松到达下一个节点,但回到前一个节点很难,在实际开发中, 经常会遇到需要回到上一个节点的情况。 ### 双向链表 @@ -20,7 +20,7 @@ ## 双向链表结构 -![img](../public/images/data-structure/img-11.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3xy769h90v20.png) - 双向链表不仅有 head 指针指向第一个节点,而且有 tail 指针指向最后一个节点。 - 每一个节点由三部分组成:item 储存数据、prev 指向前一个节点、next 指向后一个节点。 diff --git a/src/docs/data-structure/Set.md "b/assets/doc/08_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円205円253円357円274円211円351円233円206円345円220円210円.md" similarity index 94% rename from src/docs/data-structure/Set.md rename to "assets/doc/08_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円205円253円357円274円211円351円233円206円345円220円210円.md" index 3c97fc5..b82cfb6 100644 --- a/src/docs/data-structure/Set.md +++ "b/assets/doc/08_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円205円253円357円274円211円351円233円206円345円220円210円.md" @@ -1,8 +1,10 @@ -# 集合 +# JavaScript 数据结构与算法(八)集合 + +## 集合 几乎每种编程语言中,都有集合结构。集合比较常见的实现方式是哈希表,这里使用 JavaScript 的 Object 进行封装。 -## 集合特点 +### 集合特点 - 集合通常是由一组**无序的**、**不能重复的**元素构成。 @@ -12,11 +14,11 @@ - 特殊之处在于里面的元素没有顺序,也不能重复。 - 没有顺序意味着不能通过下标值进行访问,不能重复意味着相同的对象在集合中只会存在一份。 -## 封装集合 +### 封装集合 ES6 中的 `Set` 就是一个集合类,这里我们重新封装一个 `Set` 类,了解集合的底层实现。 -### 集合常见的操作 +#### 集合常见的操作 - `add(value)` 向集合添加一个新的项。 - `remove(value)` 从集合移除一个值。 @@ -26,7 +28,7 @@ ES6 中的 `Set` 就是一个集合类,这里我们重新封装一个 `Set` - `values()` 返回一个包含集合中所有值的数组。 - 还有其他的方法,用的不多,这里不做封装。 -### 代码实现 +#### 代码实现 ```js // 集合结构的封装 @@ -71,7 +73,7 @@ class Set { } ``` -### 代码测试 +#### 代码测试 ```js const set = new Set(); @@ -102,16 +104,16 @@ set.clear(); console.log(set.values()); //--> [] ``` -## 集合间的操作 +### 集合间的操作 - 并集:对于给定的两个集合,返回一个包含两个集合中所有元素的新集合。 - 交集:对于给定的两个集合,返回一个包含两个集合中共有元素的新集合。 - 差集:对于给定的两个集合,返回一个包含所有存在于第一个集合且不存在于第二个集合的元素的新集合。 - 子集:验证一个给定集合是否是另一个集合的子集。 -![img](../public/images/data-structure/img-12.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4utjffapm1w0.png) -### 并集的实现 +#### 并集的实现 ```js // union() 求两个集合的并集 @@ -133,7 +135,7 @@ union(otherSet) { } ``` -### 交集的实现 +#### 交集的实现 ```js // intersection() 求两个集合的交集 @@ -153,7 +155,7 @@ intersection(otherSet) { } ``` -### 差集的实现 +#### 差集的实现 ```js // difference() 差集 @@ -173,7 +175,7 @@ difference(otherSet) { } ``` -### 子集的实现 +#### 子集的实现 ```js // subset() 子集 @@ -190,11 +192,11 @@ subset(otherSet) { } ``` -## 集合的完整实现 +### 集合的完整实现 ```js // 集合结构的封装 -class Set { +export default class Set { constructor() { this.items = {}; } diff --git a/src/docs/data-structure/Map.md "b/assets/doc/09_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円271円235円357円274円211円345円255円227円345円205円270円.md" similarity index 92% rename from src/docs/data-structure/Map.md rename to "assets/doc/09_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円271円235円357円274円211円345円255円227円345円205円270円.md" index 0fe52b5..83a204d 100644 --- a/src/docs/data-structure/Map.md +++ "b/assets/doc/09_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円344円271円235円357円274円211円345円255円227円345円205円270円.md" @@ -1,6 +1,8 @@ -# 字典 +# JavaScript 数据结构与算法(九)字典 -## 字典特点 +## 字典 + +### 字典特点 - 字典存储的是**键值对**,主要特点是**一一对应**。 - 比如保存一个人的信息 @@ -8,12 +10,12 @@ - 字典形式:`{"age": 19, "name": "Tom", "height": 165}`,可以通过 `key` 取出 `value`。 - 此外,在字典中 key 是不能重复且无序的,而 Value 可以重复。 -## 字典和映射的关系 +### 字典和映射的关系 - 有些编程语言中称这种映射关系为**字典**,如 Swift 中的 `Dictonary`,Python 中的 `dict`。 - 有些编程语言中称这种映射关系为 **Map**,比如 Java 中的 `HashMap` 和 `TreeMap` 等。 -## 字典常见的操作 +### 字典常见的操作 - `set(key,value)` 向字典中添加新元素。 - `remove(key)` 通过使用键值来从字典中移除键值对应的数据值。 @@ -24,13 +26,13 @@ - `keys()` 将字典所包含的所有键名以数组形式返回。 - `values()` 将字典所包含的所有数值以数组形式返回。 -## 字典封装 +### 字典封装 -### 代码实现 +#### 代码实现 ```js // 字典结构的封装 -class Map { +export default class Map { constructor() { this.items = {}; } @@ -79,7 +81,7 @@ class Map { } ``` -### 代码测试 +#### 代码测试 ```js const map = new Map(); diff --git a/src/docs/data-structure/HashTable.md "b/assets/doc/10_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円357円274円211円345円223円210円345円270円214円350円241円250円.md" similarity index 87% rename from src/docs/data-structure/HashTable.md rename to "assets/doc/10_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円357円274円211円345円223円210円345円270円214円350円241円250円.md" index e05958f..a9d4b65 100644 --- a/src/docs/data-structure/HashTable.md +++ "b/assets/doc/10_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円357円274円211円345円223円210円345円270円214円350円241円250円.md" @@ -1,4 +1,4 @@ -# 哈希表 +# JavaScript 数据结构与算法(十)哈希表 ## 认识哈希表 @@ -6,14 +6,14 @@ 哈希表通常是基于数组实现的,但是相对于数组,它存在更多优势: -- 哈希表可以提供非常快速的 **插入 - 删除 - 查找** 操作。 +- 哈希表可以提供非常快速的 **插入-删除-查找** 操作。 - 无论多少数据,插入和删除值都只需接近常量的时间,即 **O(1)** 的时间复杂度。实际上,只需要几个机器指令即可完成。 - 哈希表的速度比树还要快,基本可以瞬间查找到想要的元素。 - 哈希表相对于树来说编码要简单得多。 哈希表同样存在不足之处: -- 哈希表中的数据是没有顺序的,所以不能以一种固定的方式(比如从小到大)来遍历其中的元素。 +- 哈希表中的数据是没有顺序的,所以不能以一种固定的方式(比如从小到大 )来遍历其中的元素。 - 通常情况下,哈希表中的 `key` 是不允许重复的,不能放置相同的 `key`,用于保存不同的元素。 哈希表是什么? @@ -23,11 +23,11 @@ 通过以下案例了解哈希表: -- 案例一:公司想要存储 1000 个人的信息,每一个工号对应一个员工的信息。若使用数组,增加和删除数据时比较麻烦;使用链表,获取数据时比较麻烦。有没有一种数据结构,能把某一员工的姓名转换为它对应的工号,再根据工号查找该员工的完整信息呢?没错此时就可以使用哈希表的哈希函数来实现。 +- 案例一:公司想要存储 1000 个人的信息,每一个工号对应一个员工的信息。若使用数组,增删数据时比较麻烦;使用链表,获取数据时比较麻烦。有没有一种数据结构,能把某一员工的姓名转换为它对应的工号,再根据工号查找该员工的完整信息呢?没错此时就可以使用哈希表的哈希函数来实现。 -- 案例二:存储联系人和对应的电话号码:当要查找张三的号码时,若使用数组:由于不知道存储张三数据对象的下标值,所以查找起来十分麻烦,使用链表时也同样麻烦。而使用哈希表就能通过哈希函数把张三这个名称转换为它对应的下标值,再通过下标值查找效率就非常高了。 +- 案例二:存储联系人和对应的电话号码:当要查找张三(比如)的号码时,若使用数组:由于不知道存储张三数据对象的下标值,所以查找起来十分麻烦,使用链表时也同样麻烦。而使用哈希表就能通过哈希函数把张三这个名称转换为它对应的下标值,再通过下标值查找效率就非常高了。 -也就是说:哈希表最后还是基于数组来实现的,只不过哈希表能够通过哈希函数把字符串转化为对应的下标值,建立字符串和下标值的映射关系。 +也就是说:哈希表最后还是基于数据来实现的,只不过哈希表能够通过哈希函数把字符串转化为对应的下标值,建立字符串和下标值的映射关系。 ### 认识哈希化 @@ -79,7 +79,7 @@ 如下图所示,我们将每一个数字都对 10 进行取余操作,则余数的范围 0~9 作为数组的下标值。并且,数组每一个下标值对应的位置存储的不再是一个数字了,而是存储由经过取余操作后得到相同余数的数字组成的数组或链表。 -![img](../public/images/data-structure/img-13.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.5irlba213e00.png) 这样可以根据下标值获取到整个数组或链表,之后继续在数组或链表中查找就可以了。而且,产生冲突的元素一般不会太多。 @@ -87,9 +87,9 @@ #### 开放地址法 -开放地址法的主要工作方式是**寻找空白的单元格来放置冲突的数据项**。 +开放地址法的主要工作方式是寻找空白的单元格来放置冲突的数据项。 -![img](../public/images/data-structure/img-14.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.52qzixg5w4s0.png) 根据探测空白单元格位置方式的不同,可分为三种方法: @@ -101,7 +101,7 @@ - 当插入 13 时: -经过哈希化(对 10 取余)之后得到的下标值 index=3,但是该位置已经放置了数据 33。而线性探测就是从 index 位置 +1 开始向后一个一个来查找合适的位置来放置 13,所谓合适的位置指的是空的位置,如上图中 index=4 的位置就是合适的位置。 +经过哈希化(对 10 取余)之后得到的下标值 index=3,但是该位置已经放置了数据 33。而线性探测就是从 index 位置+1 开始向后一个一个来查找合适的位置来放置 13,所谓合适的位置指的是空的位置,如上图中 index=4 的位置就是合适的位置。 - 当查询 13 时: @@ -112,7 +112,7 @@ - 当删除 13 时: - 删除操作和上述两种情况类似,但需要注意的是,删除一个数据项时,不能将该位置下标的内容设置为 null,否则会影响到之后其他的查询操作,因为一遇到为 null 的位置就会停止查找。 - - 通常删除一个位置的数据项时,我们可以将它进行特殊处理(比如设置为 -1),这样在查找时遇到 -1 就知道要继续查找。 + - 通常删除一个位置的数据项时,我们可以将它进行特殊处理(比如设置为-1),这样在查找时遇到-1 就知道要继续查找。 线性探测存在的问题: @@ -124,7 +124,7 @@ - 比如插入 13 时就会发现,连续的单元 3~7 都不允许插入数据,并且在插入的过程中需要经历多次这种情况。二次探测法可以解决该问题。 -![img](../public/images/data-structure/img-15.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.47l36021j8m0.png) ##### 二次探测 @@ -147,7 +147,7 @@ 在开放地址法中寻找空白单元格的最好的解决方式为再哈希化。 - 二次探测的步长是固定的:1,4,9,16 依次类推。 -- 现在需要一种方法:产生一种依赖关键字 (数据) 的探测序列,而不是每个关键字探测步长都一样。 +- 现在需要一种方法:产生一种依赖关键字(数据)的探测序列,而不是每个关键字探测步长都一样。 - 这样,不同的关键字即使映射到相同的数组下标,也可以使用不同的探测序列。 - 再哈希法的做法为:把关键字用另一个哈希函数,再做一次哈希化,用这次哈希化的结果作为该关键字的步长。 @@ -183,19 +183,19 @@ 可以看到,随着装填因子的增大,平均探测长度呈指数形式增长,性能较差。实际情况中,最好的装填因子取决于存储效率和速度之间的平衡,随着装填因子变小,存储效率下降,而速度上升。 - ![img](../public/images/data-structure/img-16.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.2pcxv1f720o0.png) - 二次探测和再哈希化的性能 二次探测和再哈希法性能相当,它们的性能比线性探测略好。由下图可知,随着装填因子的变大,平均探测长度呈指数形式增长,需要探测的次数也呈指数形式增长,性能不高。 - ![img](../public/images/data-structure/img-17.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.f06tizypf6g.png) - 链地址法的性能 可以看到随着装填因子的增加,平均探测长度呈线性增长,较为平缓。在开发中使用链地址法较多,比如 Java 中的 HashMap 中使用的就是链地址法。 - ![img](../public/images/data-structure/img-18.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.45s3ntwwjia0.png) ### 哈希函数 @@ -210,9 +210,9 @@ 霍纳法则:在中国霍纳法则也叫做秦久韶算法,具体算法为: -![img](../public/images/data-structure/img-19.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4kz61djvvau0.png) -求多项式的值时,首先计算最内层括号内一次多项式的值,然后由内向外逐层计算一次多项式的值。这种算法把求 n 次多项式 f(x) 的值就转化为求 n 个一次多项式的值。 +求多项式的值时,首先计算最内层括号内一次多项式的值,然后由内向外逐层计算一次多项式的值。这种算法把求 n 次多项式 f(x)的值就转化为求 n 个一次多项式的值。 - 变换之前: @@ -224,7 +224,7 @@ - 乘法次数:n 次; - 加法次数:n 次; -如果使用大 O 表示时间复杂度的话,直接从变换前的 O(N^2) 降到了 O(N)。 +如果使用大 O 表示时间复杂度的话,直接从变换前的 O(N^2)降到了 O(N)。 #### 均匀分布 @@ -279,7 +279,7 @@ console.log(hashFn("abc")); //--> 6 封装的哈希表的数据结构模型: -![img](../public/images/data-structure/img-20.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.7h3eahcbrvs0.png) 首先创建哈希表类 HashTable,并添加必要的属性和上面实现的哈希函数,再进行其他方法的实现。 @@ -297,11 +297,11 @@ class HashTable { 哈希表的插入和修改操作是同一个函数:因为,当使用者传入一个 `[key, value]` 时,如果原来不存在该 key,那么就是插入操作,如果原来已经存在该 key,那么就是修改操作。 -![img](../public/images/data-structure/img-21.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.2a81gwdznn8k.png) 实现思路: -- 首先,根据 key 获取索引值 index,将数据插入到 storage 的对应位置; +- 首先,根据 key 获取索引值 index,目的为将数据插入到 storage 的对应位置; - 然后,根据索引值取出 bucket,如果 bucket 不存在,先创建 bucket,随后放置在该索引值的位置; - 接着,判断新增还是修改原来的值。如果已经有值了,就修改该值;如果没有,就执行后续操作。 - 最后,进行新增数据操作。 @@ -438,7 +438,7 @@ size() { 为什么需要扩容? -- 前面我们在哈希表中使用的是长度为 7 的数组,由于使用的是链地址法,装填因子 (loadFactor) 可以大于 1,所以这个哈希表可以无限制地插入新数据。 +- 前面我们在哈希表中使用的是长度为 7 的数组,由于使用的是链地址法,装填因子(loadFactor)可以大于 1,所以这个哈希表可以无限制地插入新数据。 - 但是,随着数据量的增多,storage 中每一个 `index` 对应的 `bucket` 数组(链表)就会越来越长,这就会造成哈希表效率的降低。 @@ -457,7 +457,7 @@ size() { - 然后,创建一个新的容量更大的数组,让 `this.storage` 指向它。 - 最后,将 oldStorage 中的每一个 bucket 中的每一个数据取出来依次添加到 `this.storage` 指向的新数组中。 -![img](../public/images/data-structure/img-22.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.7xrayvjwh2w.png) ### resize() 的实现 @@ -484,6 +484,7 @@ resize(newLimit) { this.put(b[0], b[1]); } } + } } ``` @@ -512,7 +513,7 @@ resize(newLimit) { > 1 不是质数 -- 方法一:针对质数的特点:只能被 1 和 number 整除,不能被 2 ~ (number-1) 整除。遍历 2 ~ (num-1) 。 +- 方法一:针对质数的特点:只能被 1 和 number 整除,不能被 2 ~ (number-1)整除。遍历 2 ~ (num-1) 。 这种方法虽然能实现质数的判断,但是效率不高。 @@ -547,7 +548,7 @@ resize(newLimit) { 实现思路: -2 倍扩容或压缩之后,通过循环调用 `isPrime` 判断得到的容量是否为质数,不是则 +1,直到是为止。比如原长度:7,2 倍扩容后长度为 14,14 不是质数,`14 + 1 = 15` 不是质数,`15 + 1 = 16` 不是质数,`16 + 1 = 17` 是质数,停止循环,由此得到质数 17。 +2 倍扩容或压缩之后,通过循环调用 `isPrime` 判断得到的容量是否为质数,不是则+1,直到是为止。比如原长度:7,2 倍扩容后长度为 14,14 不是质数,`14 + 1 = 15` 不是质数,`15 + 1 = 16` 不是质数,`16 + 1 = 17` 是质数,停止循环,由此得到质数 17。 - 第一步:首先需要为 HashTable 类添加判断质数的 `isPrime` 方法和获取质数的 `getPrime` 方法: @@ -590,7 +591,7 @@ class HashTable { this.count = 0; // 当前存放的元素个数 this.limit = 7; // 哈希表长度(初始设为质数 7) - // 装填因子 (已有个数/总个数) + // 装填因子(已有个数/总个数) this.loadFactor = 0.75; this.minLoadFactor = 0.25; } diff --git a/src/docs/data-structure/Tree.md "b/assets/doc/11_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円344円270円200円357円274円211円346円240円221円.md" similarity index 75% rename from src/docs/data-structure/Tree.md rename to "assets/doc/11_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円344円270円200円357円274円211円346円240円221円.md" index ea62808..3a772ec 100644 --- a/src/docs/data-structure/Tree.md +++ "b/assets/doc/11_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円344円270円200円357円274円211円346円240円221円.md" @@ -1,10 +1,14 @@ -# 树 +# JavaScript 数据结构与算法(十一)树 -## 真实的树 +## 树结构 -![img](../public/images/data-structure/img-23.png) +### 什么是树? -## 树的特点 +#### 真实的树: + +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.6pnzzxbinjs0.png) + +#### 树的特点: - 树一般都有一个根,连接着根的是树干; - 树干会发生分叉,形成许多树枝,树枝会继续分化成更小的树枝; @@ -12,11 +16,9 @@ 现实生活中很多结构都是树的抽象,模拟的树结构相当于旋转 `180°` 的树。 -![img](../public/images/data-structure/img-24.png) - -## 树结构的优势 +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4mrygbtnd6w0.png) -树结构对比于数组/链表/哈希表有哪些优势呢? +#### 树结构对比于数组/链表/哈希表有哪些优势呢? 数组: @@ -44,12 +46,12 @@ - 树(Tree):由 n(n ≥ 0)个节点构成的有限集合。当 n = 0 时,称为空树。 - 对于任意一棵非空树(n> 0),它具备以下性质: - - 数中有一个称为根(Root)的特殊节点,用 `r` 表示; + - 数中有一个称为根(Root)的特殊节点,用 **r** 表示; - 其余节点可分为 m(m> 0)个互不相交的有限集合 T1,T2,...,Tm,其中每个集合本身又是一棵树,称为原来树的子树(SubTree)。 -## 树的常用术语 +#### 树的常用术语: -![img](../public/images/data-structure/img-25.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3t0ypfn5leo0.png) - 节点的度(Degree):节点的子树个数,比如节点 B 的度为 2; - 树的度:树的所有节点中最大的度数,如上图树的度为 2; @@ -61,24 +63,24 @@ - 节点的层次(Level):规定根节点在 1 层,其他任一节点的层数是其父节点的层数加 1。如 B 和 C 节点的层次为 2; - 树的深度(Depth):树种所有节点中的最大层次是这棵树的深度,如上图树的深度为 4; -## 树结构的表示方式 +#### 树结构的表示方式 -### 最普通的表示方法 +##### 最普通的表示方法: -![img](../public/images/data-structure/img-26.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4v9sayu9zu60.png) 如图,树结构的组成方式类似于链表,都是由一个个节点连接构成。不过,根据每个父节点子节点数量的不同,每一个父节点需要的引用数量也不同。比如节点 A 需要 3 个引用,分别指向子节点 B,C,D;B 节点需要 2 个引用,分别指向子节点 E 和 F;K 节点由于没有子节点,所以不需要引用。 这种方法缺点在于我们无法确定某一结点的引用数。 -### 儿子 - 兄弟表示法 +##### 儿子-兄弟表示法: -![img](../public/images/data-structure/img-27.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3o34yy6h0420.png) 这种表示方法可以完整地记录每个节点的数据,比如: ```js -//节点 A +//节点A Node{ //存储数据 this.data = data @@ -88,14 +90,14 @@ Node{ this.rightSibling = null } -//节点 B +//节点B Node{ this.data = data this.leftChild = E this.rightSibling = C } -//节点 F +//节点F Node{ this.data = data this.leftChild = null @@ -105,14 +107,14 @@ Node{ 这种表示法的优点在于每一个节点中引用的数量都是确定的。 -### 儿子 - 兄弟表示法旋转 +##### 儿子-兄弟表示法旋转 -以下为儿子 - 兄弟表示法组成的树结构: +以下为儿子-兄弟表示法组成的树结构: -![img](../public/images/data-structure/img-28.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.6tucreh71ok0.png) 将其顺时针旋转 45° 之后: -![img](../public/images/data-structure/img-29.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4blmsiyhevg0.png) 这样就成为了一棵二叉树,由此我们可以得出结论:任何树都可以通过二叉树进行模拟。但是这样父节点不是变了吗?其实,父节点的设置只是为了方便指向子节点,在代码实现中谁是父节点并没有关系,只要能正确找到对应节点即可。 diff --git a/src/docs/data-structure/BinaryTree.md "b/assets/doc/12_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円344円272円214円357円274円211円344円272円214円345円217円211円346円240円221円.md" similarity index 53% rename from src/docs/data-structure/BinaryTree.md rename to "assets/doc/12_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円344円272円214円357円274円211円344円272円214円345円217円211円346円240円221円.md" index e2b60be..7544ff0 100644 --- a/src/docs/data-structure/BinaryTree.md +++ "b/assets/doc/12_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円344円272円214円357円274円211円344円272円214円345円217円211円346円240円221円.md" @@ -1,43 +1,39 @@ -# 二叉树 +# JavaScript 数据结构与算法(十二)二叉树 -## 二叉树的概念 +## 二叉树 -如果树中的每一个节点最多只能有两个子节点,这样的树就称为二叉树。 +### 二叉树的概念 -## 二叉树的组成 +如果树中的每一个节点最多只能由两个子节点,这样的树就称为二叉树; + +### 二叉树的组成 - 二叉树可以为空,也就是没有节点; - 若二叉树不为空,则它由根节点和称为其左子树 TL 和右子树 TR 的两个不相交的二叉树组成; -## 二叉树的五种形态 +### 二叉树的五种形态 -![img](../public/images/data-structure/img-30.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.15ycsg4fqoio.png) -上图分别表示: -- a 空的二叉树 -- b 只有一个节点的二叉树 -- c 只有左子树 TL 的二叉树 -- d 只有右子树 TR 的二叉树 -- e 有左右两个子树的二叉树。 +上图分别表示:空的二叉树、只有一个节点的二叉树、只有左子树 TL 的二叉树、只有右子树 TR 的二叉树和有左右两个子树的二叉树。 -## 二叉树的特性 +### 二叉树的特性 - 一个二叉树的第 i 层的最大节点树为:2^(i-1)^,i>= 1; -- 深度为 k 的二叉树的最大节点总数为:2^k^ - 1,k>= 1; -- 对任何非空二叉树,若 n~0~ 表示叶子节点的个数,n~2~表示度为 2 的非叶子节点个数,那么两者满足关系:n~0~ = n~2~ + 1; - 如下图所示:H,E,I,J,G 为叶子节点,总数为 5;A,B,C,F 为度为 2 的非叶子节点,总数为 4;满足 n~0~ = n~2~ + 1 的规律。 +- 深度为 k 的二叉树的最大节点总数为:2^k^ - 1 ,k>= 1; +- 对任何非空二叉树,若 n~0~ 表示叶子节点的个数,n~2~表示度为 2 的非叶子节点个数,那么两者满足关系:n~0~ = n~2~ + 1;如下图所示:H,E,I,J,G 为叶子节点,总数为 5;A,B,C,F 为度为 2 的非叶子节点,总数为 4;满足 n~0~ = n~2~ + 1 的规律。 -![img](../public/images/data-structure/img-31.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.syjwffjltmo.png) -## 特殊的二叉树 +### 特殊的二叉树 -### 完美二叉树 +#### 完美二叉树 完美二叉树(Perfect Binary Tree)也成为满二叉树(Full Binary Tree),在二叉树中,除了最下一层的叶子节点外,每层节点都有 2 个子节点,这就构成了完美二叉树。 -![img](../public/images/data-structure/img-32.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.223b2axrocf4.png) -### 完全二叉树 +#### 完全二叉树 完全二叉树(Complete Binary Tree): @@ -45,37 +41,37 @@ - 并且,最后一层的叶子节点从左向右是连续存在,只缺失右侧若干叶子节点; - 完美二叉树是特殊的完全二叉树; -![img](../public/images/data-structure/img-33.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.5y4rglrp8qk0.png) 在上图中,由于 H 缺失了右子节点,所以它不是完全二叉树。 -## 二叉树的数据存储 +### 二叉树的数据存储 常见的二叉树存储方式为数组和链表: -### 使用数组 +#### 使用数组 - 完全二叉树:按从上到下,从左到右的方式存储数据。 -![img](../public/images/data-structure/img-34.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.29w4k62b51og.png) | 节点 | A | B | C | D | E | F | G | H | I | | :--: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | | 序号 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -使用数组存储时,取数据的时候也十分方便:左子节点的序号等于父节点序号 _ 2,右子节点的序号等于父节点序号 _ 2 + 1。 +使用数组存储时,取数据的时候也十分方便:左子节点的序号等于父节点序号 _ 2,右子节点的序号等于父节点序号 _ 2 + 1 。 - 非完全二叉树:非完全二叉树需要转换成完全二叉树才能按照上面的方案存储,这样会浪费很大的存储空间。 -![img](../public/images/data-structure/img-35.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4jgiq6r2xee0.png) | 节点 | A | B | C | ^ | ^ | F | ^ | ^ | ^ | ^ | ^ | ^ | M | | :--: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | | 序号 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -### 使用链表 +#### 使用链表 二叉树最常见的存储方式为链表:每一个节点封装成一个 Node,Node 中包含存储的数据、左节点的引用和右节点的引用。 -![img](../public/images/data-structure/img-36.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.2mlscfad5420.png) diff --git a/src/docs/data-structure/BinarySearchTree.md "b/assets/doc/13_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円344円270円211円357円274円211円344円272円214円345円217円211円346円220円234円347円264円242円346円240円221円.md" similarity index 83% rename from src/docs/data-structure/BinarySearchTree.md rename to "assets/doc/13_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円344円270円211円357円274円211円344円272円214円345円217円211円346円220円234円347円264円242円346円240円221円.md" index 23049c5..d2b229b 100644 --- a/src/docs/data-structure/BinarySearchTree.md +++ "b/assets/doc/13_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円344円270円211円357円274円211円344円272円214円345円217円211円346円220円234円347円264円242円346円240円221円.md" @@ -1,4 +1,6 @@ -# 二叉搜索树 +# JavaScript 数据结构与算法(十三)二叉搜索树 + +## 二叉搜索树 二叉搜索树(BST,Binary Search Tree),也称为二叉排序树和二叉查找树。 @@ -6,34 +8,34 @@ 如果不为空,则满足以下性质: -- 条件 1:非空左子树的所有键值小于其根节点的键值。比如树三中节点 6 的所有非空左子树的键值都小于 6; -- 条件 2:非空右子树的所有键值大于其根节点的键值;比如树三中节点 6 的所有非空右子树的键值都大于 6; +- 条件 1:非空左子树的所有键值小于其根节点的键值。比如三中节点 6 的所有非空左子树的键值都小于 6; +- 条件 2:非空右子树的所有键值大于其根节点的键值;比如三中节点 6 的所有非空右子树的键值都大于 6; - 条件 3:左、右子树本身也都是二叉搜索树; -![img](../public/images/data-structure/img-37.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.1lhxcdph4vpc.png) 如上图所示,树二和树三符合 3 个条件属于二叉树,树一不满足条件 3 所以不是二叉树。 -总结:二叉搜索树的特点主要是**较小的值总是保存在左节点上**,**相对较大的值总是保存在右节点上**。这种特点使得二叉搜索树的查询效率非常高,这也就是二叉搜索树中"搜索"的来源。 +总结:二叉搜索树的特点主要是较小的值总是保存在左节点上,相对较大的值总是保存在右节点上。这种特点使得二叉搜索树的查询效率非常高,这也就是二叉搜索树中"搜索"的来源。 ## 二叉搜索树应用举例 下面是一个二叉搜索树: -![img](../public/images/data-structure/img-38.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3l21fsg6qbc0.png) 若想在其中查找数据 10,只需要查找 4 次,查找效率非常高。 - 第 1 次:将 10 与根节点 9 进行比较,由于 10> 9,所以 10 下一步与根节点 9 的右子节点 13 比较; - 第 2 次:由于 10 < 13,所以 10 下一步与父节点 13 的左子节点 11 比较; - 第 3 次:由于 10 < 11,所以 10 下一步与父节点 11 的左子节点 10 比较; -- 第 4 次:由于 10 = 10,最终查找到数据 10。 +- 第 4 次:由于 10 = 10,最终查找到数据 10 。 -![img](../public/images/data-structure/img-39.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.5x9xyvmbxy80.png) 同样是 15 个数据,在排序好的数组中查询数据 10,需要查询 10 次: -![img](../public/images/data-structure/img-40.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.2gqz4t2jekw0.png) 其实:如果是排序好的数组,可以通过二分查找:第一次找 9,第二次找 13,第三次找 15...。我们发现如果把每次二分的数据拿出来以树的形式表示的话就是二叉搜索树。这就是数组二分法查找效率之所以高的原因。 @@ -41,7 +43,7 @@ 二叉搜索树有四个最基本的属性:指向节点的根(root),节点中的键(key)、左指针(right)、右指针(right)。 -![img](../public/images/data-structure/img-41.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.5vdbb5to1n40.png) 所以,二叉搜索树中除了定义 root 属性外,还应定义一个节点内部类,里面包含每个节点中的 left、right 和 key 三个属性。 @@ -56,7 +58,7 @@ class Node { } ``` -## 二叉搜索树的常见操作 +### 二叉搜索树的常见操作: - `insert(key)` 向树中插入一个新的键。 - `search(key)` 在树中查找一个键,如果节点存在,则返回 true;如果不存在,则返回 `false`。 @@ -67,7 +69,7 @@ class Node { - `max` 返回树中最大的值/键。 - `remove(key)` 从树中移除某个键。 -### 插入数据 +#### 插入数据 实现思路: @@ -75,7 +77,7 @@ class Node { - 然后判断根节点是否存在,不存在时通过:this.root = newNode,直接把新节点作为二叉搜索树的根节点。 - 若存在根节点则重新定义一个内部方法 `insertNode()` 用于查找插入点。 -`insert(key)` 代码实现 +insert(key) 代码实现 ```js // insert(key) 插入数据 @@ -91,11 +93,11 @@ insert(key) { } ``` -`insertNode()` 的实现思路: +insertNode() 的实现思路: 根据比较传入的两个节点,一直查找新节点适合插入的位置,直到成功插入新节点为止。 -- 当 newNode.key < node.key 向左查找: +- 当 newNode.key < node.key 向左查找: - 情况 1:当 node 无左子节点时,直接插入: @@ -133,17 +135,17 @@ insertNode(root, node) { } ``` -### 遍历数据 +#### 遍历数据 这里所说的树的遍历不仅仅针对二叉搜索树,而是适用于所有的二叉树。由于树结构不是线性结构,所以遍历方式有多种选择,常见的三种二叉树遍历方式为: -- 先序遍历 -- 中序遍历 -- 后序遍历 +- 先序遍历; +- 中序遍历; +- 后序遍历; 还有层序遍历,使用较少。 -#### 先序遍历 +##### 先序遍历 先序遍历的过程为: @@ -151,7 +153,7 @@ insertNode(root, node) { 然后,遍历其左子树; 最后,遍历其右子树; -![img](../public/images/data-structure/img-42.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.69ooahvtbbo0.png) 如上图所示,二叉树的节点遍历顺序为:A -> B -> D -> H -> I -> E -> C -> F -> G。 @@ -173,7 +175,7 @@ preorderTraversalNode(node, result) { } ``` -#### 中序遍历 +##### 中序遍历 实现思路:与先序遍历原理相同,只不过是遍历的顺序不一样了。 @@ -183,9 +185,9 @@ preorderTraversalNode(node, result) { 过程图解: -![img](../public/images/data-structure/img-43.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.762l4sxdr7o0.png) -输出节点的顺序应为:3 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13 -> 14 -> 15 -> 18 -> 20 -> 25。 +输出节点的顺序应为:3 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13 -> 14 -> 15 -> 18 -> 20 -> 25 。 代码实现: @@ -205,7 +207,7 @@ inorderTraversalNode(node, result) { } ``` -#### 后序遍历 +##### 后序遍历 实现思路:与先序遍历原理相同,只不过是遍历的顺序不一样了。 @@ -215,9 +217,9 @@ inorderTraversalNode(node, result) { 过程图解: -![img](../public/images/data-structure/img-44.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.5lqmen4jds80.png) -输出节点的顺序应为:3 -> 6 -> 5 -> 8 -> 10 -> 9 -> 7 -> 12 -> 14 -> 13 -> 18 -> 25 -> 20 -> 15 -> 11。 +输出节点的顺序应为:3 -> 6 -> 5 -> 8 -> 10 -> 9 -> 7 -> 12 -> 14 -> 13 -> 18 -> 25 -> 20 -> 15 -> 11 。 代码实现: @@ -237,20 +239,17 @@ postorderTraversalNode(node, result) { } ``` -#### 总结 +##### 总结 -以遍历根(父)节点的顺序来区分三种遍历方式。 -- 先序遍历先遍历根节点(根左右) -- 中序遍历第二遍历根节点(左根右) -- 后续遍历最后遍历根节点。(左右根) +以遍历根(父)节点的顺序来区分三种遍历方式。比如:先序遍历先遍历根节点、中序遍历第二遍历根节点、后续遍历最后遍历根节点。 -### 查找数据 +#### 查找数据 -#### 查找最大值或最小值 +##### 查找最大值或最小值 在二叉搜索树中查找最值非常简单,最小值在二叉搜索树的最左边,最大值在二叉搜索树的最右边。只需要一直向左/右查找就能得到最值,如下图所示: -![img](../public/images/data-structure/img-45.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3h3yfhyqgi00.png) 代码实现: @@ -276,14 +275,14 @@ max() { } ``` -#### 查找特定值 +##### 查找特定值 查找二叉搜索树当中的特定值效率也非常高。只需要从根节点开始将需要查找节点的 key 值与之比较,若 node.key < root 则向左查找,若 node.key> root 就向右查找,直到找到或查找到 null 为止。这里可以使用递归实现,也可以采用循环来实现。 代码实现: ```js -// search(key) 查找二叉搜索树中是否有相同的 key,存在返回 true,否则返回 false +// search(key) 查找二叉搜索树中是否有相同的key,存在返回 true,否则返回 false search(key) { return this.searchNode(this.root, key); } @@ -320,7 +319,7 @@ search2(key) { } ``` -### 删除数据 +#### 删除数据 实现思路: @@ -360,7 +359,7 @@ while (currentNode.key !== key) { - 删除的是只有一个子节点的节点; - 删除的是有两个子节点的节点; -#### 删除的是叶子节点 +##### 删除的是叶子节点 删除的是叶子节点分两种情况: @@ -368,13 +367,13 @@ while (currentNode.key !== key) { 当该叶子节点为根节点时,如下图所示,此时 current == this.root,直接通过:this.root = null,删除根节点。 - ![img](../public/images/data-structure/img-46.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.1j9353rx9b7k.png) - 叶子节点不为根节点 当该叶子节点不为根节点时也有两种情况,如下图所示 - ![img](../public/images/data-structure/img-47.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3r99a6ocvug0.png) 若 current = 8,可以通过:parent.left = null,删除节点 8; @@ -397,7 +396,7 @@ while (currentNode.key !== key) { } ``` -#### 删除的是只有一个子节点的节点 +##### 删除的是只有一个子节点的节点 有六种情况: @@ -409,7 +408,7 @@ while (currentNode.key !== key) { - 情况 3:current 为父节点 parent 的右子节点(isLeftChild == false),如节点 9,此时通过:parent.right = current.left,删除节点 9; -![img](../public/images/data-structure/img-48.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.27lwqd0qfnpc.png) 当 current 存在右子节点时(current.left = null): @@ -419,7 +418,7 @@ while (currentNode.key !== key) { - 情况 6:current 为父节点 parent 的右子节点(isLeftChild == false),如节点 9,此时通过:parent.right = current.right,删除节点 9; -![img](../public/images/data-structure/img-49.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3edzg72fx7y0.png) 代码实现: @@ -454,11 +453,11 @@ while (currentNode.key !== key) { } ``` -#### 删除的是有两个子节点的节点 +##### 删除的是有两个子节点的节点 这种情况十分复杂,首先依据以下二叉搜索树,讨论这样的问题: -![img](../public/images/data-structure/img-50.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4g0geeyv6ya0.png) **删除节点 9** @@ -467,7 +466,7 @@ while (currentNode.key !== key) { - 方式 1:从节点 9 的左子树中选择一合适的节点替代节点 9,可知节点 8 符合要求; - 方式 2:从节点 9 的右子树中选择一合适的节点替代节点 9,可知节点 10 符合要求; -![img](../public/images/data-structure/img-51.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.73rduwimfvo0.png) **删除节点 7** @@ -476,7 +475,7 @@ while (currentNode.key !== key) { - 方式 1:从节点 7 的左子树中选择一合适的节点替代节点 7,可知节点 5 符合要求; - 方式 2:从节点 7 的右子树中选择一合适的节点替代节点 7,可知节点 8 符合要求; -![img](../public/images/data-structure/img-52.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.2h9hjd5bhwo0.png) **删除节点 15** @@ -485,7 +484,7 @@ while (currentNode.key !== key) { - 方式 1:从节点 15 的左子树中选择一合适的节点替代节点 15,可知节点 14 符合要求; - 方式 2:从节点 15 的右子树中选择一合适的节点替代节点 15,可知节点 18 符合要求; -![img](../public/images/data-structure/img-53.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4f5tzwdvueq0.png) 相信你已经发现其中的规律了! @@ -496,14 +495,14 @@ while (currentNode.key !== key) { - current 左子树中比 current 小一点点的节点,即 current 左子树中的最大值; - current 右子树中比 current 大一点点的节点,即 current 右子树中的最小值; -##### 前驱&后继 +###### 前驱&后继 在二叉搜索树中,这两个特殊的节点有特殊的名字: - 比 current 小一点点的节点,称为 current 节点的前驱。比如下图中的节点 5 就是节点 7 的前驱; - 比 current 大一点点的节点,称为 current 节点的后继。比如下图中的节点 8 就是节点 7 的后继; -![img](../public/images/data-structure/img-54.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.71vg0g9z7io0.png) 查找需要被删除的节点 current 的后继时,需要在 current 的右子树中查找最小值,即在 current 的右子树中一直向左遍历查找; @@ -558,7 +557,7 @@ getSuccessor(delNode) { } ``` -#### 完整实现 +##### 完整实现 ```js // 删除节点 @@ -677,15 +676,15 @@ getSuccessor(delNode) { } ``` -# 平衡树 +## 平衡树 二叉搜索树的缺陷:当插入的数据是有序的数据,就会造成二叉搜索树的深度过大。比如原二叉搜索树由 11 7 15 组成,如下图所示: -![img](../public/images/data-structure/img-55.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.1nkd51rg5dz4.png) 当插入一组有序数据:6 5 4 3 2 就会变成深度过大的搜索二叉树,会严重影响二叉搜索树的性能。 -![img](../public/images/data-structure/img-56.png) +![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.154bnlgtd5z4.png) 非平衡树 @@ -696,7 +695,7 @@ getSuccessor(delNode) { 树的平衡性 -为了能以较快的时间 O(log n) 来操作一棵树,我们需要保证树总是平衡的: +为了能以较快的时间 O(log n)来操作一棵树,我们需要保证树总是平衡的: - 起码大部分是平衡的,此时的时间复杂度也是接近 O(log n) 的; - 这就要求树中每个节点左边的子孙节点的个数,应该尽可能地等于右边的子孙节点的个数; diff --git a/src/docs/data-structure/Graph.md "b/assets/doc/14_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円345円233円233円357円274円211円345円233円276円.md" similarity index 57% rename from src/docs/data-structure/Graph.md rename to "assets/doc/14_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円345円233円233円357円274円211円345円233円276円.md" index 10d2788..032ff4a 100644 --- a/src/docs/data-structure/Graph.md +++ "b/assets/doc/14_JavaScript346円225円260円346円215円256円347円273円223円346円236円204円344円270円216円347円256円227円346円263円225円357円274円210円345円215円201円345円233円233円357円274円211円345円233円276円.md" @@ -1,28 +1,28 @@ -# 图 +# JavaScript 数据结构与算法(十四)图 ## 图的概念 -在计算机程序设计中,图也是一种非常常见的数据结构。图论是一个非常大的话题,在数学上起源于哥尼斯堡七桥问题。 +在计算机程序设计中,图也是一种非常常见的数据结构,图论其实是一个非常大的话题,在数学上起源于哥尼斯堡七桥问题。 ### 什么是图? - 图是一种与树有些相似的数据结构。 - 实际上,在数学的概念上,树是图的一种。 - - 我们知道树可以用来模拟很多现实的数据结构,比如:家谱/公司的组织架构等等。 + - 我们知道树可以用来模拟很多现实的数据结构,比如:家谱/公司组织架构等等。 -- 图长什么样子呢?或者什么样的数据使用图来模拟更合适呢? +- 那么图长什么样子呢?或者什么样的数据使用图来模拟更合适呢? - 人与人之间的关系网 - ![img](../public/images/data-structure/img-57.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4cdhxz0ereu0.png) - 互联网中的网络关系 - ![img](../public/images/data-structure/img-58.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.4ljxyy69a1s0.png) - 广州地铁图 - ![img](../public/images/data-structure/img-59.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.46k2cvwmthw0.png) -- 什么是图呢? +- 那么,什么是图呢? - 我们会发现,上面的结点(其实图中叫顶点 Vertex)之间的关系,是不能使用树来表示(几叉树都不可以)。 - 这个时候,我们就可以使用**图**来模拟它们。 @@ -31,19 +31,17 @@ - 一组顶点:通常用 V (Vertex) 表示顶点的集合 - 一组边:通常用 E (Edge) 表示边的集合 - 边是顶点和顶点之间的连线 - - 边可以是有向的,也可以是无向的。(比如 A --- B,通常表示无向。A --> B,通常表示有向) + - 边可以是有向的,也可以是无向的。(比如 A --- B,通常表示无向。 A --> B,通常表示有向) ### 图的术语 -我们在学习树的时候,树有很多的其他术语,了解这些术语有助于我们更深层次的理解图。 +#### 术语 -图的术语也非常多,如果你找一本专门讲图的各个方面的书籍,会发现只是术语就可以占据一个章节。 - -这里,这里介绍几个比较常见的术语,某些术语后面用到的时候,再了解,没有用到的,不做赘述。 - -通过下图来了解图的术语: - -![img](../public/images/data-structure/img-60.png) +- 我们在学习树的时候,树有很多的其他术语,了解这些术语有助于我们更深层次的理解图。 +- 但是图的术语其实非常多,如果你找一本专门讲图的各个方面的书籍,会发现只是术语就可以占据一个章节。 +- 这里,这里介绍几个比较常见的术语,某些术语后面用到的时候,再了解,没有用到的,不做赘述。 +- 下面这是个抽象出来的图 + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.rr153grdbc0.png) - 顶点 @@ -53,7 +51,7 @@ - 边 - 边表示顶点和顶点之间的连线。 - - 比如地铁站中两个站点之间的直接连线,就是一个边。 + - 比如地铁站中两个站点之间的直接连线, 就是一个边。 - 注意:这里的边不要叫做路径,路径有其他的概念,后面会区分。 - 相邻顶点 @@ -69,30 +67,32 @@ - 路径 - - 路径是顶点 `v1`,`v2`...,`vn` 的一个连续序列,比如上图中 `0 1 5 9` 就是一条路径。 - - 简单路径:简单路径要求不包含重复的顶点。比如 `0 1 5 9` 是一条简单路径。 + - 路径是顶点 `v1`,`v2`...,`vn` 的一个连续序列, 比如上图中 `0 1 5 9` 就是一条路径。 + - 简单路径: 简单路径要求不包含重复的顶点. 比如 `0 1 5 9` 是一条简单路径。 - 回路:第一个顶点和最后一个顶点相同的路径称为回路。比如 `0 1 5 6 3 0`。 - 无向图 - 上面的图就是一张无向图,因为所有的边都没有方向。 - - 比如 `0 - 1` 之间有边,那么说明这条边可以保证 `0 -> 1`,也可以保证 `1 -> 0`。 + - 比如 `0 - 1` 之间有变,那么说明这条边可以保证 `0 -> 1`,也可以保证 `1 -> 0`。 - 有向图 - 有向图表示的图中的边是有方向的。 - 比如 `0 -> 1`,不能保证一定可以 `1 -> 0`,要根据方向来定。 +#### 无权图和带权图 + - 无权图 - - 如上图就是一张无权图,边没有携带权重。 - - 上图中的边是没有任何意义的,不能说 `0 - 1` 的边,比 `4 - 9` 的边更远或者用的时间更长。 + - 我们上面的图就是一张无权图(边没有携带权重) + - 我们上面的图中的边是没有任何意义的,不能收 `0 - 1` 的边,比 `4 - 9` 的边更远或者用的时间更长。 - 带权图 - 带权图表示边有一定的权重 - 这里的权重可以是任意你希望表示的数据:比如距离或者花费的时间或者票价。 - - 我们来看一张有向和带权的图: - ![img](../public/images/data-structure/img-61.png) + - 我们来看一张有向和带权的图 + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3q0nj5eq5p80.png) ### 现实建模 @@ -110,70 +110,74 @@ - 建模人员可以利用这个系统有效的判断从一个城市到另一个城市的最小航行成本。 ​ -## 图的表示 +## 二、图的表示 -一个图包含很多顶点,另外包含顶点和顶点之间的连线(边),这两个都是非常重要的图信息,因此都需要在程序中体现出来。 +我们知道一个图包含很多顶点,另外包含顶点和顶点之间的连线(边),这两个都是非常重要的图信息,因此都需要在程序中体现出来。 ### 顶点表示 - 顶点的表示相对简单 - 上面的顶点,我们抽象成了 1 2 3 4,也可以抽象成 A B C D。在后面的案例中,我们使用 A B C D。 - - 那么这些 A B C D 我们可以使用一个数组来存储起来 (存储所有的顶点)。 - - 当然,A B C D 有可能还表示其他含义的数据 (比如村庄的名字),这个时候,可以另外创建一个数组,用于存储对应的其他数据。 + - 那么这些 A B C D 我们可以使用一个数组来存储起来(存储所有的顶点)。 + - 当然,A B C D 有可能还表示其他含义的数据(比如村庄的名字),这个时候,可以另外创建一个数组,用于存储对应的其他数据。 -- 边的表示略微复杂,因为边是两个顶点之间的关系,所以表示起来会稍微麻烦一些。 +- 边的表示略微复杂 + - 因为边是两个顶点之间的关系,所以表示起来会稍微麻烦一些。 + - 下面是变常见的表示方式。 ### 邻接矩阵 - 概述 - - 邻接矩阵让每个节点和一个整数向关联,该整数作为数组的下标值。 - - 我们用一个二维数组来表示顶点之间的连接。 - - ![img](../public/images/data-structure/img-62.png) + - 邻接矩阵让每个节点和一个整数向关联, 该整数作为数组的下标值. + - 我们用一个二维数组来表示顶点之间的连接. + - 演示 + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.66y7l5b21nw0.png) - 图片解析 - 在二维数组中,0 表示没有连线,1 表示有连线。 - - 通过二维数组,我们可以很快的找到一个顶点和哪些顶点有连线。(比如 A 顶点,只需要 遍历第一行即可) + - 通过二维数组,我们可以很快的找到一个顶点和哪些顶点有连线。(比如 A 顶点, 只需要 遍历第一行即可) - 另外,A - A,B - B(也就是顶点到自己的连线),通常使用 0 表示。 - 邻接矩阵的问题 - 如果是一个无向图,邻接矩阵展示出来的二维数组,其实是一个对称图。 - 也就是 A -> D 是 1 的时候,对称的位置 D -> 1 一定也是 1。 - 那么这种情况下会造成空间的浪费,解决办法需自己去研究下。 - - 如果图是一个稀疏图 - 那么矩阵中将存在大量的 0,这意味着我们浪费了计算机存储空间来表示根本不存在的边。 - 而且即使只有一个边,我们也必须遍历一行来找出这个边,也浪费很多时间。 + - 也就是 A -> D 是 1 的时候,对称的位置 D -> 1 一定也是 1。 + - 那么这种情况下会造成空间的浪费,解决办法需自己去研究下。 + + - 邻接矩阵还有一个比较严重的问题就是如果图是一个稀疏图 + - 那么矩阵中将存在大量的 0,这意味着我们浪费了计算机存储空间来表示根本不存在的边。 + - 而且即使只有一个边,我们也必须遍历一行来找出这个边,也浪费很多时间。 ### 邻接表 - 概述 - 邻接表由图中每个顶点以及和顶点相邻的顶点列表组成。 - - 这个列表有很多中方式来存储:数组/链表/字典 (哈希表) 都可以。 - - ![img](../public/images/data-structure/img-63.png) + - 这个列表有很多中方式来存储:数组/链表/字典(哈希表)都可以。 + - 演示 + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3mu1hv8a84u0.png) - 图片解析 - 比如我们要表示和 A 顶点有关联的顶点(边),A 和 B/C/D 有边,那么我们可以通过 A 找到 对应的数组/链表/字典,再取出其中的内容。 + - 其实图片比较容易理解 + - 比如我们要表示和 A 顶点有关联的顶点(边),A 和 B/C/D 有边,那么我们可以通过 A 找到 对应的数组/链表/字典,再取出其中的内容就可以啦。 - 邻接表的问题 - - 邻接表计算"出度"是比较简单的(出度:指向别人的数量,入度:指向自己的数量) + - 邻接表计算"出度"是比较简单的(出度:指向别人的数量, 入度: 指向自己的数量) - 邻接表如果需要计算有向图的"入度",那么是一件非常麻烦的事情。 - 它必须构造一个"逆邻接表",才能有效的计算"入度"。而临街矩阵会非常简单。 -## 图的封装 +## 三、图的封装 ### 创建图类 -先来创建 Graph 类,定义了两个属性: -- `vertexes` 用于存储所有的顶点,使用一个数组来保存。 -- `adjList` adj 是 adjoin 的缩写,邻接的意思。adjList 用于存储所有的边,这里采用邻接表的形式。 +- 先来创建 Graph 类,定义了两个属性: + - `vertexes` 用于存储所有的顶点,使用一个数组来保存。 + - `adjList` adj 是 adjoin 的缩写,邻接的意思。adjList 用于存储所有的边,这里采用邻接表的形式。 ```js class Graph { @@ -184,46 +188,39 @@ class Graph { } ``` -### 方法 +### 添加方法 -#### 添加顶点 - -向图中添加一些顶点。 -- 将添加的顶点放入到数组中。 -- 另外,给该顶点创建一个数组 `[]`,该数组用于存储顶点连接的所有的边。(回顾邻接表的实现方式) +- 添加顶点:可以向图中添加一些顶点。 + - 将添加的顶点放入到数组中。 + - 另外,给该顶点创建一个数组`[]`,该数组用于存储顶点连接的所有的边.(回顾邻接表的实现方式) ```js // 添加顶点 addVertex(val) { // 添加点 this.vertexes.push(val) - // 添加点的关系 采用邻接矩阵法 结构用 Map + // 添加点的关系 采用邻接矩阵法 结构用Map this.adjList.set(val, []) } ``` -#### 添加边 - -可以指定顶点和顶点之间的边。 - -- 添加边需要传入两个顶点,因为边是两个顶点之间的边,边不可能单独存在。 -- 根据顶点 v 取出对应的数组,将 w 加入到它的数组中。 -- 根据顶点 w 取出对应的数组,将 v 加入到它的数组中。 -- 因为这里实现的是无向图,所以边是可以双向的。 +- 添加边:可以指定顶点和顶点之间的边。 + - 添加边需要传入两个顶点,因为边是两个顶点之间的边,边不可能单独存在。 + - 根据顶点 v 取出对应的数组,将 w 加入到它的数组中。 + - 根据顶点 w 取出对应的数组,将 v 加入到它的数组中。 + - 因为这里实现的是无向图,所以边是可以双向的。 ```js // 添加边 addEdge(val1, val2) { - // 添加边需要传入两个顶点,因为边是两个顶点之间的边,边不可能单独存在。 - // 这里实现的是无向图,所以这里不考虑方向问题 + // 添加边需要传入两个顶点, 因为边是两个顶点之间的边, 边不可能单独存在. + // 这里实现的是无向图, 所以这里不考虑方向问题 this.adjList.get(val1).push(val2) this.adjList.get(val2).push(val1) } ``` -#### toString 方法 - -为了能够正确的显示图的结果,就是拿出二维数组的每一项。 +toString 方法:为了能够正确的显示图的结果,就是拿出二维数组的每一项。 ```js // 输出图结构 @@ -266,20 +263,20 @@ graph.addEdge("B", "F"); graph.addEdge("E", "I"); ``` -## 图的遍历 +## 四、图的遍历 和其他数据结构一样,需要通过某种算法来遍历图结构中每一个数据。这样可以保证,在我们需要时,通过这种算法来访问某个顶点的数据以及它对应的边。 ### 遍历的方式 -图的遍历算法的思想在于必须访问每个第一次访问的节点,并且追踪有哪些顶点还没有被访问到。 +- 图的遍历思想 + 图的遍历算法的思想在于必须访问每个第一次访问的节点,并且追踪有哪些顶点还没有被访问到。 - 有两种算法可以对图进行遍历 - - 广度优先搜索 (Breadth-First Search, 简称 BFS) - - 深度优先搜索 (Depth-First Search, 简称 DFS) - - 这两种遍历算法,都需要明确指定第一个被访问的顶点。 + - 广度优先搜索(Breadth-First Search, 简称 BFS) + - 深度优先搜索(Depth-First Search, 简称 DFS) + - 两种遍历算法,都需要明确指定第一个被访问的顶点。 - 遍历的注意点 @@ -292,18 +289,18 @@ graph.addEdge("E", "I"); - BFS 基于队列,入队列的顶点先被探索。 - DFS 基于栈,通过将顶点存入栈中,顶点是沿着路径被探索的,存在新的相邻顶点就去访问。 -为了记录顶点是否被访问过,我们使用三种颜色来反应它们的状态。(或者两种颜色也可以) - -- **白色**表示该顶点还没有被访问。 -- **灰色**表示该顶点被访问过,但并未被探索过。 -- **黑色**表示该顶点被访问过且被完全探索过。 +- 为了记录顶点是否被访问过,我们使用三种颜色来反应它们的状态。(或者两种颜色也可以) + - **白色**表示该顶点还没有被访问. + - **灰色**表示该顶点被访问过, 但并未被探索过. + - **黑色**表示该顶点被访问过且被完全探索过. + - 初始化颜色代码 ```js // 初始化顶点的颜色 -initializeColor() { - // 白色:表示该顶点还没有被访问。 - // 灰色:表示该顶点被访问过,但并未被探索过。 - // 黑色:表示该顶点被访问过且被完全探索过。 +_initializeColor() { + // 白色: 表示该顶点还没有被访问. + // 灰色: 表示该顶点被访问过, 但并未被探索过. + // 黑色: 表示该顶点被访问过且被完全探索过. let colors = [] for (let i = 0; i < this.vertexes.length; i++) { colors[this.vertexes[i]] = "white" @@ -312,19 +309,19 @@ initializeColor() { } ``` -### 广度优先搜索 (BFS) +### 广度优先搜索(BFS) - 广度优先搜索算法的思路 广度优先算法会从指定的第一个顶点开始遍历图,先访问其所有的相邻点,就像一次访问图的一层。换句话说,就是先宽后深的访问顶点。 - 图解 BFS - ![img](../public/images/data-structure/img-64.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.3vz7fx7tgvs0.png) - 广度优先搜索的实现 1. 创建一个队列 Q - 2. 将 v 标注为被发现的 (灰色), 并将 v 将入队列 Q - 3. 如果 Q 非空,执行下面的步骤: + 2. 将 v 标注为被发现的(灰色), 并将 v 将入队列 Q + 3. 如果 Q 非空, 执行下面的步骤: - 将 v 从 Q 中取出队列 - 将 v 标注为被发现的灰色 - 将 v 所有的未被访问过的邻接点(白色),加入到队列中 @@ -377,19 +374,19 @@ initializeColor() { console.log(result); // A B C D E F G H I ``` -### 深度优先搜索 (DFS) +### 深度优先搜索(DFS) 深度优先搜索的思路: - 深度优先搜索算法将会从第一个指定的顶点开始遍历图,沿着路径知道这条路径最后被访问了。 -- 接着原路回退并探索下一条路径。 +- 接着原路回退并探索吓一条路径。 - 图解 DFS - ![img](../public/images/data-structure/img-65.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.1bjimck65r8g.png) 深度优先搜索算法的实现: -广度优先搜索算法我们使用的是队列,这里的深度优先搜索算法可以使用栈完成,也可以使用递归。(递归本质上就是函数栈的调用) - +- 广度优先搜索算法我们使用的是队列,这里可以使用栈完成,也可以使用递归。 +- 方便代码书写,我们还是使用递归(递归本质上就是函数栈的调用) - 深度优先搜索算法的代码: ```js @@ -404,7 +401,7 @@ initializeColor() { } } } - // dfs 的递归方法 这里直接使用函数的调用栈 + // dfs的递归方法 这里直接使用函数的调用栈 _dfsVisit(val, color, handle) { // 1. 将颜色设置为访问中 color[val] = "gray" @@ -439,6 +436,6 @@ initializeColor() { ``` - 递归的代码较难理解一些,这副图来帮助理解过程: - ![img](../public/images/data-structure/img-66.png) + ![image](https://cdn.jsdelivr.net/gh/XPoet/image-hosting@master/JavaScript-数据结构与算法/image.6z6nkgmevxo0.png) diff --git a/package.json b/package.json index 27a133d..0d766d9 100644 --- a/package.json +++ b/package.json @@ -1,29 +1,28 @@ { - "name": "js-data-structure-and-algorithm", - "version": "0.0.1", + "name": "js-data-structures-and-algorithms", + "version": "1.0.0", "description": "JavaScript 数据结构与算法", - "author": "XPoet ", "main": "index.js", "scripts": { - "dev": "vitepress dev src --open", - "preview": "vitepress preview src", - "build": "vitepress build src" - }, - "repository": { - "type": "git", - "url": "git+https://github.com/XPoet/js-data-structure-and-algorithm.git" + "build": "webpack --mode production", + "start": "webpack-dev-server --mode development --open" }, "keywords": [ - "javascript", - "data-structure", - "algorithm" + "webpack", + "babel", + "es6" ], - "license": "MIT", - "bugs": { - "url": "https://github.com/XPoet/js-data-structure-and-algorithm/issues" - }, - "homepage": "https://github.com/XPoet/js-data-structure-and-algorithm#readme", + "author": "XPoet", + "license": "ISC", "devDependencies": { - "vitepress": "^1.2.2" + "@babel/core": "^7.10.5", + "@babel/preset-env": "^7.10.4", + "babel-loader": "^8.1.0", + "css-loader": "^3.6.0", + "html-webpack-plugin": "^4.3.0", + "style-loader": "^1.2.1", + "webpack": "^4.43.0", + "webpack-cli": "^3.3.12", + "webpack-dev-server": "^3.11.0" } } diff --git a/src/.vitepress/config.mts b/src/.vitepress/config.mts deleted file mode 100644 index fb3296c..0000000 --- a/src/.vitepress/config.mts +++ /dev/null @@ -1,88 +0,0 @@ -import { defineConfig } from 'vitepress' - -// https://vitepress.dev/reference/site-config -export default defineConfig({ - title: "数据结构与算法", - - description: "JavaScript 数据结构与算法", - - lang: 'zh-CN', - - lastUpdated: true, - - srcDir: 'docs', - - outDir:'../dist', - - head: [ - ['link', { rel: 'icon', href: '/images/logo.png' }], - ], - - markdown: { - lineNumbers: true, // 代码行号 - image: { - lazyLoading: true // 图片懒加载 - } - }, - - // https://vitepress.dev/reference/default-theme-config - themeConfig: { - logo: '/images/logo.png', - - outline: { - level: [2, 4] - }, - - search: { - provider: 'local' - }, - - nav: [ - { text: '前言', link: '/foreword', activeMatch: '/foreword' }, - { text: '数据结构', link: '/data-structure/Array', activeMatch: '/data-structure/' }, - { text: '算法', link: '/algorithm/sort', activeMatch: '/algorithm/' } - ], - - sidebar: { - // 数据结构 - '/data-structure/': { - items: [ - { text: '数组', link: '/data-structure/Array' }, - { text: '栈', link: '/data-structure/Stack' }, - { text: '队列', link: '/data-structure/Queue' }, - { text: '优先队列', link: '/data-structure/PriorityQueue' }, - { text: '单向链表', link: '/data-structure/LinkedList' }, - { text: '双向链表', link: '/data-structure/DoubleLinkedList' }, - { text: '集合', link: '/data-structure/Set' }, - { text: '字典', link: '/data-structure/Map' }, - { text: '哈希表', link: '/data-structure/HashTable' }, - { text: '树', link: '/data-structure/Tree' }, - { text: '二叉树', link: '/data-structure/BinaryTree' }, - { text: '二叉搜索树', link: '/data-structure/BinarySearchTree' }, - { text: '图', link: '/data-structure/Graph' }, - ] - }, - - // 算法 - '/algorithm/': { - text: '算法', - collapsed: false, - items: [ - { text: '排序算法', link: '/algorithm/sort' }, - { text: '搜索算法', link: '/algorithm/search' }, - { text: '算法设计思想', link: '/algorithm/idea' }, - { text: '经典算法真题', link: '/algorithm/classic' }, - ] - }, - }, - - socialLinks: [ - { icon: 'github', link: 'https://github.com/XPoet/js-data-structure-and-algorithm' } - ], - - footer: { - message: 'Released under the AGPL-3.0 License', - copyright: 'Copyright © 2019-present XPoet' - }, - } -}) diff --git a/src/docs/public/data-structure/DoublyLinkedList/doublyLinkedList.js b/src/DoublyLinkedList/doublyLinkedList.js similarity index 98% rename from src/docs/public/data-structure/DoublyLinkedList/doublyLinkedList.js rename to src/DoublyLinkedList/doublyLinkedList.js index f0a421a..81d2bd0 100644 --- a/src/docs/public/data-structure/DoublyLinkedList/doublyLinkedList.js +++ b/src/DoublyLinkedList/doublyLinkedList.js @@ -1,4 +1,4 @@ -import { LinkedList, Node } from '../LinkedList/linkedList.js'; +import { LinkedList, Node } from '../LinkedList/linkedList'; // 双向链表结构的封装 diff --git a/src/docs/public/data-structure/DoublyLinkedList/index.js b/src/DoublyLinkedList/index.js similarity index 88% rename from src/docs/public/data-structure/DoublyLinkedList/index.js rename to src/DoublyLinkedList/index.js index d1e373e..ef15c0b 100644 --- a/src/docs/public/data-structure/DoublyLinkedList/index.js +++ b/src/DoublyLinkedList/index.js @@ -1,4 +1,4 @@ -import { DoublyLinkedList } from './doublyLinkedList.js'; +import { DoublyLinkedList } from './doublyLinkedList'; // ---------------- 封装的双向链表结构测试 ---------------- // console.log('// ----- 双向链表结构测试 START -----//'); @@ -39,10 +39,10 @@ console.log(doublyLinkedList.remove('111111')); console.log(doublyLinkedList); // forwardToString() 测试 -console.log(doublyLinkedList.forwardToString()); +// console.log(doublyLinkedList.forwardToString()); // backwardString() 测试 -console.log(doublyLinkedList.backwardString()); +// console.log(doublyLinkedList.backwardString()); console.log('// ----- 双向链表结构测试 END -----//'); diff --git a/src/Graph/graph.js b/src/Graph/graph.js new file mode 100644 index 0000000..bdd7da6 --- /dev/null +++ b/src/Graph/graph.js @@ -0,0 +1,114 @@ +import Dictionay from "../Map/map" +import Queue from "../Queue/queue" +// 封装图类 +export default class Graph { + constructor() { + this.vertexes = [] // 存储顶点 + this.adjList = new Dictionay() //存储边信息 + } + // 添加顶点 + addVertex(val) { + // 添加点 + this.vertexes.push(val) + // 添加点的关系 采用邻接矩阵法 结构用set + this.adjList.set(val, []) + } + + // 添加边 + addEdge(val1, val2) { + // 添加边需要传入两个顶点, 因为边是两个顶点之间的边, 边不可能单独存在. + // 这里实现的是无向图, 所以这里不考虑方向问题 + this.adjList.get(val1).push(val2) + this.adjList.get(val2).push(val1) + } + + // 输出图结构 + toString() { + let res = '' + for (let i = 0; i < this.vertexes.length; i++) { + res += this.vertexes[i] + "->" + let adj = this.adjList.get(this.vertexes[i]) + for (let j = 0; j < adj.length; j++) { + res += adj[j] + "" + } + res += "\n" + } + return res + } + + // 初始化顶点的颜色 + _initializeColor() { + // 白色: 表示该顶点还没有被访问. + // 灰色: 表示该顶点被访问过, 但并未被探索过. + // 黑色: 表示该顶点被访问过且被完全探索过. + let colors = [] + for (let i = 0; i < this.vertexes.length; i++) { + colors[this.vertexes[i]] = "white" + } + return colors + } + + // 广度优先搜索 + bfs(handle) { + // 1.初始化颜色 + let color = this._initializeColor() + // 2. 创建队列 + let queue = new Queue + // 3. 将传入的顶点放入队列 + queue.enqueue(this.vertexes[0]) + // 4.依赖队列操作数据 队列不为空时一直持续 + while (!queue.isEmpty()) { + // 4.1 拿到队头 + let qVal = queue.dequeue() + // 4.2 拿到队头所关联(相连)的点并设置为访问中状态(灰色) + let qAdj = this.adjList.get(qVal) + color[qVal] = "gray" + // 4.3 将队头关联的点添加到队尾 + // 这一步是完成bfs的关键,依赖队列的先进先出的特点。 + for (let i = 0; i < qAdj.length; i++) { + let a = qAdj[i] + if (color[a] === "white") { + color[a] = "gray" + queue.enqueue(a) + } + } + // 4.5设置访问完的点为黑色。 + color[qVal] = "black" + if (handle) [ + handle(qVal) + ] + } + } + + // 深度优先搜索 + dfs(handle) { + // 1.初始化颜色 + let color = this._initializeColor() + // 2. 遍历所有顶点,开始访问 + for (let i = 0; i < this.vertexes.length; i++) { + if (color[this.vertexes[i]] === "white") { + this._dfsVisit(this.vertexes[i], color, handle) + } + } + } + // dfs的递归方法 这里直接使用函数的调用栈 + _dfsVisit(val, color, handle) { + // 1. 将颜色设置为访问中 + color[val] = "gray" + // 2. 执行相应的回调 + if (handle) { + handle(val) + } + // 3. 拿与该点相邻的点,对每个点操作 + let adj = this.adjList.get(val) + for (let i = 0; i < adj.length; i++) { + let w = adj[i] + // 如果相邻点未未访问状态,开始访问。 + if (color[w] === "white") { + this._dfsVisit(w, color, handle) + } + } + // 4. 处理完后设置为访问过点。 + color[val] = "black" + } +} \ No newline at end of file diff --git a/src/Graph/index.js b/src/Graph/index.js new file mode 100644 index 0000000..bd2f6f8 --- /dev/null +++ b/src/Graph/index.js @@ -0,0 +1,44 @@ +import Graph from './graph'; +// ---------------- 封装的图构测试 ---------------- // +console.log('// ----- 图结构测试 START -----//'); + + +// 测试代码 +let graph = new Graph() +// 添加顶点 +let myVertexes = ["A", "B", "C", "D", "E", "F", "G", "H", "I"] +for (let i = 0; i < myVertexes.length; i++) { + graph.addVertex(myVertexes[i]) +} +// 添加边 +graph.addEdge('A', 'B'); +graph.addEdge('A', 'C'); +graph.addEdge('A', 'D'); +graph.addEdge('C', 'D'); +graph.addEdge('C', 'G'); +graph.addEdge('D', 'G'); +graph.addEdge('D', 'H'); +graph.addEdge('B', 'E'); +graph.addEdge('B', 'F'); +graph.addEdge('E', 'I'); +// 输出图结构 +console.log(graph.toString()) + + +// 调用广度优先算法 +let result = "" +graph.bfs(function (v) { + result += v + " " +}) +// 输出广度优先 +console.log(result) // A B C D E F G H I + +// 调用深度优先算法 +result = "" +graph.dfs(function (v) { + result += v + " " +}) +// 输出深度优先 +console.log(result) //A B E I F C D G H + +console.log('// ----- 图结构测试 END -----//'); \ No newline at end of file diff --git a/src/docs/public/data-structure/HashTable/hashTable.js b/src/HashTable/hashTable.js similarity index 99% rename from src/docs/public/data-structure/HashTable/hashTable.js rename to src/HashTable/hashTable.js index e30cc9f..de430be 100644 --- a/src/docs/public/data-structure/HashTable/hashTable.js +++ b/src/HashTable/hashTable.js @@ -179,6 +179,7 @@ export class HashTable { this.put(b[0], b[1]); } } + } } } diff --git a/src/docs/public/data-structure/HashTable/index.js b/src/HashTable/index.js similarity index 94% rename from src/docs/public/data-structure/HashTable/index.js rename to src/HashTable/index.js index fa08b48..6265497 100644 --- a/src/docs/public/data-structure/HashTable/index.js +++ b/src/HashTable/index.js @@ -1,5 +1,4 @@ -import { hashFn, HashTable, isPrime } from './hashTable.js'; - +import { hashFn, HashTable, isPrime } from './hashTable'; // ---------------- 封装的哈希表结构测试 ---------------- // console.log('// ----- 哈希表结构测试 START -----//'); diff --git a/src/docs/public/data-structure/LinkedList/index.js b/src/LinkedList/index.js similarity index 96% rename from src/docs/public/data-structure/LinkedList/index.js rename to src/LinkedList/index.js index f3e7a43..501c0f2 100644 --- a/src/docs/public/data-structure/LinkedList/index.js +++ b/src/LinkedList/index.js @@ -1,4 +1,4 @@ -import { LinkedList } from './linkedList.js'; +import { LinkedList } from './linkedList'; // ---------------- 封装的单向链表结构测试 ---------------- // console.log('// ----- 单向链表结构测试 START -----//'); diff --git a/src/docs/public/data-structure/LinkedList/linkedList.js b/src/LinkedList/linkedList.js similarity index 100% rename from src/docs/public/data-structure/LinkedList/linkedList.js rename to src/LinkedList/linkedList.js diff --git a/src/docs/public/data-structure/Map/index.js b/src/Map/index.js similarity index 96% rename from src/docs/public/data-structure/Map/index.js rename to src/Map/index.js index 2b8daf9..a94dba5 100644 --- a/src/docs/public/data-structure/Map/index.js +++ b/src/Map/index.js @@ -1,4 +1,4 @@ -import Map from './map.js'; +import Map from './map'; // ---------------- 封装的字典结构测试 ---------------- // console.log('// ----- 字典结构测试 START -----//'); diff --git a/src/docs/public/data-structure/Map/map.js b/src/Map/map.js similarity index 100% rename from src/docs/public/data-structure/Map/map.js rename to src/Map/map.js diff --git a/src/docs/public/data-structure/PriorityQueue/index.js b/src/PriorityQueue/index.js similarity index 95% rename from src/docs/public/data-structure/PriorityQueue/index.js rename to src/PriorityQueue/index.js index 1bbf1ec..db7c578 100644 --- a/src/docs/public/data-structure/PriorityQueue/index.js +++ b/src/PriorityQueue/index.js @@ -1,4 +1,4 @@ -import { PriorityQueue } from './priorityQueue.js'; +import { PriorityQueue } from './priorityQueue'; // ---------------- 封装的优先队列结构测试 ---------------- // console.log('// ----- 优先队列结构测试 START -----//'); diff --git a/src/docs/public/data-structure/PriorityQueue/priorityQueue.js b/src/PriorityQueue/priorityQueue.js similarity index 98% rename from src/docs/public/data-structure/PriorityQueue/priorityQueue.js rename to src/PriorityQueue/priorityQueue.js index fb6971a..cd98b84 100644 --- a/src/docs/public/data-structure/PriorityQueue/priorityQueue.js +++ b/src/PriorityQueue/priorityQueue.js @@ -1,4 +1,4 @@ -import Queue from '../Queue/queue.js'; +import Queue from '../Queue/queue'; /** * 优先队列结构的封装 diff --git a/src/docs/public/data-structure/Queue/index.js b/src/Queue/index.js similarity index 87% rename from src/docs/public/data-structure/Queue/index.js rename to src/Queue/index.js index 473ddce..7661845 100644 --- a/src/docs/public/data-structure/Queue/index.js +++ b/src/Queue/index.js @@ -1,5 +1,5 @@ -import Queue from './queue.js'; -import passGame from './passGame.js'; +import Queue from './queue'; +import passGame from './passGame'; // ---------------- 封装的队列结构测试 ---------------- // console.log('// ----- 队列结构测试 START -----//'); @@ -30,7 +30,7 @@ console.log(queue.size()); //--> 2 console.log(queue.toString()); //--> c d -// 击鼓传花游戏算法封装 passGame() 测试 +// passGame() 测试 const names = ['lily', 'lucy', 'tom', 'tony', 'jack']; const targetIndex = passGame(names, 4); console.log('击鼓传花', names[targetIndex]); //--> lily diff --git a/src/docs/public/data-structure/Queue/passGame.js b/src/Queue/passGame.js similarity index 100% rename from src/docs/public/data-structure/Queue/passGame.js rename to src/Queue/passGame.js diff --git a/src/docs/public/data-structure/Queue/queue.js b/src/Queue/queue.js similarity index 100% rename from src/docs/public/data-structure/Queue/queue.js rename to src/Queue/queue.js diff --git a/src/docs/public/data-structure/Set/index.js b/src/Set/index.js similarity index 98% rename from src/docs/public/data-structure/Set/index.js rename to src/Set/index.js index addc4d1..d26be46 100644 --- a/src/docs/public/data-structure/Set/index.js +++ b/src/Set/index.js @@ -1,4 +1,4 @@ -import Set from './set.js'; +import Set from './set'; // ---------------- 封装的栈结构测试 ---------------- // console.log('// ----- 集合结构测试 START -----//'); diff --git a/src/docs/public/data-structure/Set/set.js b/src/Set/set.js similarity index 100% rename from src/docs/public/data-structure/Set/set.js rename to src/Set/set.js diff --git a/src/docs/public/data-structure/Stack/dec2bin.js b/src/Stack/dec2bin.js similarity index 94% rename from src/docs/public/data-structure/Stack/dec2bin.js rename to src/Stack/dec2bin.js index 573f8ac..a63c42b 100644 --- a/src/docs/public/data-structure/Stack/dec2bin.js +++ b/src/Stack/dec2bin.js @@ -1,4 +1,4 @@ -import Stack from './stack.js'; +import Stack from './stack'; // 利用栈结构的特点封装实现十进制转换为二进制的方法 export default function dec2bin(dec) { diff --git a/src/docs/public/data-structure/Stack/index.js b/src/Stack/index.js similarity index 91% rename from src/docs/public/data-structure/Stack/index.js rename to src/Stack/index.js index c3ec169..3ae0106 100644 --- a/src/docs/public/data-structure/Stack/index.js +++ b/src/Stack/index.js @@ -1,5 +1,5 @@ -import Stack from './stack.js'; -import dec2bin from './dec2bin.js'; +import Stack from './stack'; +import dec2bin from './dec2bin'; // ---------------- 封装的栈结构测试 ---------------- // console.log('// ----- 栈结构测试 START -----//'); diff --git a/src/docs/public/data-structure/Stack/stack.js b/src/Stack/stack.js similarity index 88% rename from src/docs/public/data-structure/Stack/stack.js rename to src/Stack/stack.js index 96c97e9..e04f7f5 100644 --- a/src/docs/public/data-structure/Stack/stack.js +++ b/src/Stack/stack.js @@ -12,13 +12,11 @@ export default class Stack { // pop() 出栈操作,从栈中取出元素,并返回取出的那个元素 pop() { - if(this.isEmpty()) throw new Error('栈空了'); return this.items.pop(); } // peek() 查看栈顶元素 peek() { - if(this.isEmpty()) throw new Error('栈空了'); return this.items[this.items.length - 1]; } diff --git a/src/docs/public/data-structure/BinarySearchTree/index.js b/src/Tree/index.js similarity index 73% rename from src/docs/public/data-structure/BinarySearchTree/index.js rename to src/Tree/index.js index 9eb06f2..324312c 100644 --- a/src/docs/public/data-structure/BinarySearchTree/index.js +++ b/src/Tree/index.js @@ -1,6 +1,6 @@ -import { BinarySearchTree } from './tree.js'; -// ---------------- 封装的二叉搜索树结构测试 ---------------- // -console.log('// ----- 二叉搜索树结构测试 START -----//'); +import { BinarySearchTree } from './tree'; +// ---------------- 封装的树结构测试 ---------------- // +console.log('// ----- 树结构测试 START -----//'); // 二叉搜索树测试 // insert() 插入 @@ -31,14 +31,14 @@ console.log('max', binarySearchTree.max()); console.log('search(98)-递归实现', binarySearchTree.search(98)); console.log('search(10)-递归实现', binarySearchTree.search(10)); -console.log('search(98)-while 循环实现', binarySearchTree.search2(98)); -console.log('search(10)-while 循环实现', binarySearchTree.search2(10)); +console.log('search(98)-while循环实现', binarySearchTree.search2(98)); +console.log('search(10)-while循环实现', binarySearchTree.search2(10)); console.log('remove(20)'); binarySearchTree.remove(20); console.log(binarySearchTree); console.log(binarySearchTree.inorderTraversal()); -console.log('// ----- 二叉搜索树结构测试 END -----//'); +console.log('// -----树结构测试 END -----//'); diff --git a/src/docs/public/data-structure/BinarySearchTree/tree.js b/src/Tree/tree.js similarity index 99% rename from src/docs/public/data-structure/BinarySearchTree/tree.js rename to src/Tree/tree.js index 230d283..9cd7258 100644 --- a/src/docs/public/data-structure/BinarySearchTree/tree.js +++ b/src/Tree/tree.js @@ -1,10 +1,12 @@ // 节点类 class Node { + constructor(key) { this.key = key; this.left = null; this.right = null; } + } diff --git a/src/docs/algorithm/classic.md b/src/docs/algorithm/classic.md deleted file mode 100644 index c9e34ab..0000000 --- a/src/docs/algorithm/classic.md +++ /dev/null @@ -1,457 +0,0 @@ -# 经典算法真题 - -## 数组扁平化 - -- 通过递归来实现,当元素为数组时递归调用,兼容性好。 - - ```js - function flattenArray(array) { - // 检查传入的参数是否为数组 - if (!Array.isArray(array)) return - - // 定义结果数组,用于存储扁平化后的元素 - let result = [] - - // 使用 reduce 方法遍历传入的数组 - result = array.reduce(function (pre, item) { - // 判断当前元素是否为数组 - if (Array.isArray(item)) { - // 如果是数组,则递归调用 flattenArray 函数,结果与前一个结果合并 - return pre.concat(flattenArray(item)) - } - // 如果不是数组,则直接将元素添加到结果数组中 - return pre.concat(item) - }, []) // 初始值为空数组 - - // 返回扁平化后的结果数组 - return result - } - - // 测试代码,输出扁平化后的数组 - console.log(flattenArray([1, 2, [3, 4, [5, 6]]])) // [1, 2, 3, 4, 5, 6] - ``` - -- 利用 `toString()` 方法,缺点是改变了元素的类型,只适合于数组中元素都是整数的情况。 - - ```js - function flattenArray(array) { - return array - .toString() - .split(',') - .map(function (item) { - return +item - }) - } - - console.log(flattenArray([1, 2, [3, 4, [5, 6]]])) // [1, 2, 3, 4, 5, 6] - ``` - -## 数组去重 - -```js -// ES5 -function unique(array) { - // 检查传入的参数是否为数组,或者数组长度是否小于等于 1,如果是则直接返回 - if (!Array.isArray(array) || array.length <= 1) return array - - // 定义结果数组,用于存储唯一的元素 - var result = [] - - // 遍历传入的数组 - array.forEach(function (item) { - // 检查结果数组中是否已经包含当前元素 - if (result.indexOf(item) === -1) { - // 如果不包含,则将当前元素添加到结果数组中 - result.push(item) - } - }) - - // 返回去重后的结果数组 - return result -} - -// 测试,输出去重后的数组 -console.log(unique([1, 2, 2, 3, 4, 4, 5])) // [1, 2, 3, 4, 5] - - - -// ES6+ -function unique(array) { - // 检查传入的参数是否为数组,或者数组长度是否小于等于 1,如果是则直接返回原数组 - if (!Array.isArray(array) || array.length <= 1) return array - - // 使用 Set 数据结构去重,然后使用扩展运算符将 Set 转换回数组 - return [...new Set(array)] -} - -// 测试,输出去重后的数组 -console.log(unique([1, 1, 1, 2, 3, 3, 4, 5])) // [1, 2, 3, 4, 5] - -``` - -## 求数组的最大值和最小值 - -```js -// 定义一个包含若干数字的数组 -const array = [6, 4, 1, 8, 2, 11, 23] - -// 使用 Math.max 方法找到数组中的最大值 -// apply 方法将数组展开为 Math.max 方法的参数 -console.log(Math.max.apply(null, array)) // 23 - -// 使用 Math.min 方法找到数组中的最小值 -// apply 方法将数组展开为 Math.min 方法的参数 -console.log(Math.min.apply(null, array)) // 1 - -``` - -## 求两个数的最大公约数 - -基本思想是采用**辗转相除**的方法,用大的数去除以小的那个数,然后再用小的数去除以的得到的余数,一直这样递归下去,直到余数为 0 时,最后的被除数就是两个数的最大公约数。 - -```js -// 定义一个函数来计算两个数的最大公约数(GCD) -function getMaxCommonDivisor(a, b) { - // 使用递归方式实现欧几里得算法 - // 如果 b 为 0,则返回 a,此时 a 就是最大公约数 - if (b === 0) return a - - // 否则递归调用函数,将 b 和 a 对 b 取余后的结果作为新的参数 - return getMaxCommonDivisor(b, a % b) -} - -// 测试代码,输出 12 和 8 的最大公约数 -console.log(getMaxCommonDivisor(12, 8)) // 4 - -// 测试代码,输出 12 和 16 的最大公约数 -console.log(getMaxCommonDivisor(12, 16)) // 4 -``` - -## 求两个数的最小公倍数 - -在 JavaScript 中,可以通过分解质因数并计算两数的最大公约数(GCD)的方式来求两个数的最小公倍数(LCM)。最小公倍数可以通过以下公式计算: - -``` -LCM(a, b) = |a * b| / GCD(a, b) -``` - -其中 `|a * b|` 表示 `a` 和 `b` 的乘积的绝对值,`GCD(a, b)` 表示 `a` 和 `b` 的最大公约数。 - -以下是使用欧几里得算法计算最大公约数进而求最小公倍数的 JavaScript 实现: - -```javascript -// 计算两个数的最大公约数(GCD) -function gcd(a, b) { - // 使用递归方式实现欧几里得算法 - if (b === 0) { - // 如果 b 为 0,则返回 a,此时 a 就是最大公约数 - return a - } - // 否则递归调用函数,将 b 和 a 对 b 取余后的结果作为新的参数 - return gcd(b, a % b) -} - -// 计算两个数的最小公倍数(LCM) -function lcm(a, b) { - // 最小公倍数公式:|a * b| / gcd(a, b) - // 使用绝对值函数 Math.abs 确保结果为正数 - return Math.abs(a * b) / gcd(a, b) -} - -// 测试代码,输出 4 和 6 的最小公倍数 -console.log(lcm(4, 6)) // 12 -``` - -## 实现 IndexOf 方法 - -详情查看 → [搜索算法](./search) - -## 判断一个字符串是否为回文字符串 - -回文字符串是一个正读和反读都一样的字符串。 - -```js -function isPalindrome(str) { - // 移除所有非字母和非数字字符,并将字符串转换为小写 - const cleanedStr = str.replace(/[^A-Za-z0-9]/g, '').toLowerCase() - - // 获取清理后的字符串的反转版 - const reversedStr = cleanedStr.split('').reverse().join('') - - // 比较清理后的字符串和它的反转版 - return cleanedStr === reversedStr -} - -// 示例用法 -console.log(isPalindrome('A man, a plan, a canal: Panama')) // 输出 true -console.log(isPalindrome('race a car')) // 输出 false -``` - -## 累加函数 - -```js -function sum(...args) { - // 初始化结果变量为 0 - let result = 0 - - // 使用 reduce 函数将传入的初始参数数组求和,并赋值给 result - result = args.reduce(function (pre, item) { - return pre + item - }, 0) - - // 定义一个内部函数 add,用于继续累加新的参数 - const add = function (...args) { - // 将新的参数数组求和并加到当前 result 的值上 - result = args.reduce(function (pre, item) { - return pre + item - }, result) - - // 返回 add 函数自身,以便实现链式调用 - return add - } - - // 重写 add 函数的 valueOf 方法,使其在被转换为原始值时返回 result 的值 - add.valueOf = function () { - console.log(result) - } - - // 返回 add 函数,以便外部可以继续累加 - return add -} - -// 使用示例 -sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).valueOf() // 55 -sum(1, 2, 3)(2).valueOf() // 8 -sum(1, 2, 3, 4, 5)(2, 3, 4).valueOf() // 24 -``` - -## 查找一篇英文文章中出现频率最高的单词 - -```js -function findMostWord(text) { - // 将文本转换为小写,以便忽略大小写差异 - text = text.toLowerCase() - - // 使用正则表达式去除文本中的标点符号,并按空格分割成单词数组 - const words = text.replace(/[.,!?;:()"]/g, '').split(/\s+/) - - // 创建一个对象来存储每个单词的出现频率 - const wordCount = {} - - // 遍历单词数组,统计每个单词的出现次数 - words.forEach((word) => { - if (wordCount[word]) { - wordCount[word]++ - } else { - wordCount[word] = 1 - } - }) - - // 初始化两个变量,用于存储频率最高的单词及其出现次数 - let maxCount = 0 - let mostFrequentWord = '' - - // 遍历 wordCount 对象,找出出现次数最多的单词 - for (const word in wordCount) { - if (wordCount[word]> maxCount) { - maxCount = wordCount[word] - mostFrequentWord = word - } - } - - // 返回频率最高的单词及其出现次数 - return { word: mostFrequentWord, count: maxCount } -} - -// 示例使用 -console.log(findMostWord('This is a test. This test is only a test.')) // { word: 'test', count: 3 } -``` - -## 斐波那契数列 - -大家都知道斐波那契数列,现在要求输入一个整数 n(n <= 39),请你输出斐波那契数列的第 n 项。 - -思路: - -斐波那契数列的规律是,第一项为 0,第二项为 1,第三项以后的值都等于前面两项的和,因此可以通过循环的方式,不断通过叠加来实现第 n 项值的构建。 - -通过循环而不是递归的方式来实现,时间复杂度降为了 O(n),空间复杂度为 O(1)。 - -代码实现: - -```js -function fibonacci(n) { - // 检查输入是否有效 - if (n <= 0) { - return 'Invalid input. The number should be greater than 0.' - } - - // 斐波那契数列的第一个数 - if (n === 1) { - return 0 - } - - // 斐波那契数列的第二个数 - if (n === 2) { - return 1 - } - - // 初始化前两个斐波那契数 - let prevPrev = 0 - let prev = 1 - - // 通过迭代计算斐波那契数列的第 n 个数 - for (let i = 3; i <= n; i++) { - const current = prevPrev + prev // 当前斐波那契数是前两个数之和 - prevPrev = prev // 更新前前一个数 - prev = current // 更新前一个数 - } - - // 返回第 n 个斐波那契数 - return prev -} - -// 示例使用 -console.log(fibonacci(1)) // 输出:0 -console.log(fibonacci(2)) // 输出:1 -console.log(fibonacci(3)) // 输出:1 -console.log(fibonacci(10)) // 输出:34 -console.log(fibonacci(20)) // 输出:4181 -console.log(fibonacci(-5)) // 输出:'Invalid input. The number should be greater than 0.' -``` - -## 跳台阶 - -一只青蛙一次可以跳上 1 级台阶,也可以跳上 2 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。 - -思路: - -跳台阶的问题是一个动态规划的问题,由于一次只能够跳 1 级或者 2 级,因此跳上 n 级台阶一共有两种方案,一种是从 n-1 跳上,一种是从 n-2 级跳上,因此 `f(n) = f(n-1) + f(n-2)`。 - -和斐波那契数列类似,不过初始两项的值变为了 1 和 2,后面每项的值等于前面两项的和。 - -代码实现: - -```js -function jumpStairs(n) { - if (n <= 0) { - return 0 // 如果台阶数小于或等于 0,返回 0 - } - if (n === 1) { - return 1 // 只有一级台阶时,只有 1 种跳法 - } - if (n === 2) { - return 2 // 有两级台阶时,有 2 种跳法(一步一级或一步两级) - } - - // 初始化前两项,dp 数组的大小需要是 n+1 以便存储所有结果 - const dp = [0, 1, 2] - - // 从第 3 级台阶开始计算,直到第 n 级台阶 - for (let i = 3; i <= n; i++) { - dp[i] = dp[i - 1] + dp[i - 2] // 动态规划公式:f(n) = f(n-1) + f(n-2) - } - - return dp[n] // 返回第 n 级台阶的跳法数 -} - -// 示例使用 -console.log(jumpStairs(0)) // 输出:0 -console.log(jumpStairs(1)) // 输出:1 -console.log(jumpStairs(2)) // 输出:2 -console.log(jumpStairs(3)) // 输出:3 -console.log(jumpStairs(4)) // 输出:3 -console.log(jumpStairs(10)) // 输出:89 -``` - -## 最小的 K 个数 - -输入 n 个整数,找出其中最小的 K 个数。 - -例如:输入 `[4, 5, 1, 6, 2, 7, 3, 8]` 这 8 个数字,则最小的 4 个数字是 `[1, 2, 3, 4]`。 - -思路: - -- 第一种思路是首先将数组排序,排序后再取最小的 k 个数。这一种方法的时间复杂度取决于我们选择的排序算法的时间复杂度,最好的情况下为 O(n log n)。 - - ```js - function findKSmallestNumbers(nums, k) { - nums.sort((a, b) => a - b) - return nums.slice(0, k) - } - - const nums = [4, 5, 1, 6, 2, 7, 3, 8] - const k = 4 - console.log(findKSmallestNumbers(nums, k)) // 输出:[1, 2, 3, 4] - ``` - -- 第二种思路是由于我们只需要获得最小的 k 个数,这 k 个数不一定是按序排序的。因此我们可以使用快速排序中的 partition 函数来实现。每一次选择一个枢纽值,将数组分为比枢纽值大和比枢纽值小的两个部分,判断枢纽值的位置,如果该枢纽值的位置为 k-1 的话,那么枢纽值和它前面的所有数字就是最小的 k 个数。如果枢纽值的位置小于 k-1 的话,假设枢纽值的位置为 n-1,那么我们已经找到了前 n 小的数字了,我们就还需要到后半部分去寻找后半部分 k-n 小的值,进行划分。当该枢纽值的位置比 k-1 大时,说明最小的 k 个值还在左半部分,我们需要继续对左半部分进行划分。这一种方法的平均时间复杂度为 O(n)。 - - ```js - function quickSelect(nums, k) { - function partition(nums, left, right, pivotIndex) { - const pivotValue = nums[pivotIndex] - ;[nums[pivotIndex], nums[right]] = [nums[right], nums[pivotIndex]] - let storeIndex = left - for (let i = left; i < right; i++) { - if (nums[i] < pivotValue) { - ;[nums[storeIndex], nums[i]] = [nums[i], nums[storeIndex]] - storeIndex++ - } - } - ;[nums[right], nums[storeIndex]] = [nums[storeIndex], nums[right]] - return storeIndex - } - - function select(nums, left, right, k) { - if (left === right) return nums[left] - const pivotIndex = Math.floor(Math.random() * (right - left + 1)) + left - const newPivotIndex = partition(nums, left, right, pivotIndex) - if (newPivotIndex === k - 1) { - return nums[newPivotIndex] - } - if (newPivotIndex < k - 1) { - return select(nums, newPivotIndex + 1, right, k) - } - return select(nums, left, newPivotIndex - 1, k) - } - - const sortedNums = [...nums] - const kthSmallest = select(sortedNums, 0, nums.length - 1, k - 1) - - // 获取 k 个最小数 - const kSmallestNums = [] - for (let i = 0; i < nums.length; i++) { - if (nums[i] <= kthSmallest) { - kSmallestNums.push(nums[i]) - if (kSmallestNums.length === k) break - } - } - return kSmallestNums - } - - const nums = [4, 5, 1, 6, 2, 7, 3, 8] - const k = 4 - console.log(quickSelect(nums, k)) // 输出:[1, 2, 3, 4] - ``` - -- 第三种方法是维护一个容量为 k 的最大堆。对数组进行遍历时,如果堆的容量还没有达到 k,则直接将元素加入到堆中,这就相当于我们假设前 k 个数就是最小的 k 个数。对 k 以后的元素遍历时,我们将该元素与堆的最大值进行比较,如果比最大值小,那么我们则将最大值与其交换,然后调整堆。如果大于等于堆的最大值,则继续向后遍历,直到数组遍历完成。这一种方法的平均时间复杂度为 O(nlogk)。 - - ```js - function findKSmallestNumbersWithMaxHeap(nums, k) { - nums.sort((a, b) => b - a) // 先将数组逆序,方便模拟最大堆 - const result = [] - for (let i = 0; i < nums.length && result.length < k; i++) { - if (result.length === 0 || nums[i] <= result[0]) { - result.unshift(nums[i]) // 添加到堆顶 - result.sort((a, b) => b - a) // 重新调整堆顶元素为最大值 - } - } - return result - } - - const nums = [4, 5, 1, 6, 2, 7, 3, 8] - const k = 4 - console.log(findKSmallestNumbersWithMaxHeap(nums, k)) // 输出:[1, 2, 3, 4] - ``` - diff --git a/src/docs/algorithm/idea.md b/src/docs/algorithm/idea.md deleted file mode 100644 index defeda0..0000000 --- a/src/docs/algorithm/idea.md +++ /dev/null @@ -1,1317 +0,0 @@ -# 算法设计思想 - -## 分而治之 - -分而治之(分治法)是一种常见的算法设计思想,其核心是将一个大问题分解成小的子问题,分别解决这些子问题,然后将子问题的解合并起来得到原问题的解。这种思想在很多算法中都有广泛的应用,特别是在解决递归问题时很常见。 - -### 基本步骤 - -1. **分解(Divide)**:将原问题划分成若干个规模较小的子问题。 -2. **解决(Conquer)**:递归地解决这些子问题,如果子问题规模足够小,则直接求解。 -3. **合并(Combine)**:将子问题的解合并成原问题的解。 - -### 使用场景 - -- 排序算法:如**归并排序**和**快速排序**。 -- 搜索算法:如**二分搜索**。 -- 数据压缩:如哈夫曼编码。 -- 分布式计算:如 MapReduce 等。 - -### 分而治之的应用 - -#### 多数元素 - -题目来源:[LeetCode #169 简单](https://leetcode.cn/problems/majority-element/description/) - -给定一个大小为 `n` 的数组 `nums`,返回其中的多数元素。多数元素是指在数组中出现次数大于 `⌊ n/2 ⌋` 的元素。 - -你可以假设数组是非空的,并且给定的数组总是存在多数元素。 - -示例 1: -> 输入:nums = [3, 2, 3] -> 输出:3 - -示例 2: -> 输入:nums = [2, 2, 1, 1, 1, 2, 2] -> 输出:2 - -提示: -- `n == nums.length` -- `1 <= n <= 5 * 104` -- `-10^9 <= nums[i] <= 10^9` - -解题步骤: -1. **分解**:将数组分成左右两部分。 -2. **解决子问题**:递归地在左右两部分中分别找出多数元素。 -3. **合并**: - - 如果左右部分的多数元素相同,则该元素即为整个数组的多数元素。 - - 如果左右部分的多数元素不同,则需要统计这两个元素在整个数组中的出现次数,出现次数较多的元素即为多数元素。 - -代码实现: - -```javascript -function majorityElement(nums) { - // 辅助函数:统计元素在给定区间内的出现次数 - function countInRange(nums, num, left, right) { - let count = 0 - for (let i = left; i <= right; i++) { - if (nums[i] === num) { - count++ - } - } - return count - } - - // 分治算法主函数 - function majorityElementRec(nums, left, right) { - // 基本情况:只有一个元素时 - if (left === right) { - return nums[left] - } - - // 将数组分成左右两部分 - const mid = Math.floor((left + right) / 2) - const leftMajority = majorityElementRec(nums, left, mid) - const rightMajority = majorityElementRec(nums, mid + 1, right) - - // 如果左右部分的多数元素相同,则返回该元素 - if (leftMajority === rightMajority) { - return leftMajority - } - - // 否则统计左右多数元素在整个区间内的出现次数 - const leftCount = countInRange(nums, leftMajority, left, right) - const rightCount = countInRange(nums, rightMajority, left, right) - - // 返回出现次数较多的元素 - return leftCount> rightCount ? leftMajority : rightMajority - } - - // 调用递归函数,从整个数组开始 - return majorityElementRec(nums, 0, nums.length - 1) -} - -// 测试用例 -console.log(majorityElement([3, 2, 3])) // 输出:3 -console.log(majorityElement([2, 2, 1, 1, 1, 2, 2])) // 输出:2 -console.log(majorityElement([1])) // 输出:1 -console.log(majorityElement([1, 1, 2, 2, 2, 1, 1, 1])) // 输出:1 -``` - -- **时间复杂度**:O(n log n),每次递归将数组分为两部分,类似于归并排序,每层的合并操作需要线性时间,递归深度为 log n,因此总时间复杂度为 O(n log n)。 - -- **空间复杂度**:O(log n),递归调用栈的深度为 log n,因此空间复杂度为 O(log n)(不包括输入和输出所占用的空间)。 - -#### 排序数组 - -题目来源:[LeetCode #912 中等](https://leetcode.cn/problems/sort-an-array/description) - -给你一个整数数组 `nums`,请你将该数组升序排列。 - -示例 1: -> 输入:nums = [5, 2, 3, 1] -> 输出:[1, 2, 3, 5] - -示例 2: -> 输入:nums = [5, 1, 1, 2, 0, 0] -> 输出:[0, 0, 1, 1, 2, 5] - -要将一个整数数组进行排序,我们可以使用分而治之的思想,这里我们选择**归并排序**作为实现方法,归并排序是一种稳定的排序算法。 - -解题步骤: - -1. **递归终止条件**:当数组长度小于等于 1 时,返回数组本身,因为它已经是有序的。 -2. **分解数组**:找到数组的中点,将数组分成左右两部分。 -3. **递归排序**:递归地对左右两部分进行排序。 -4. **合并**:合并两个有序的子数组成一个有序的数组。 - -代码实现: - -```javascript -function sortArray(nums) { - // 主函数,调用归并排序函数 - return mergeSort(nums) -} - -function mergeSort(nums) { - // 基本情况:如果数组长度小于等于 1,直接返回 - if (nums.length <= 1) { - return nums - } - - // 计算中点 - const mid = Math.floor(nums.length / 2) - - // 分别对左右两部分进行排序 - const left = mergeSort(nums.slice(0, mid)) - const right = mergeSort(nums.slice(mid)) - - // 合并排序好的左右两部分 - return merge(left, right) -} - -function merge(left, right) { - const sortedArray = [] - let i = 0 - let j = 0 - - // 合并两个有序数组 - while (i < left.length && j < right.length) { - if (left[i] < right[j]) { - sortedArray.push(left[i]) - i++ - } else { - sortedArray.push(right[j]) - j++ - } - } - - // 将剩余的元素添加到结果数组 - while (i < left.length) { - sortedArray.push(left[i]) - i++ - } - while (j < right.length) { - sortedArray.push(right[j]) - j++ - } - - return sortedArray -} - -// 示例测试 -console.log(sortArray([5, 2, 3, 1])) // 输出:[1, 2, 3, 5] -console.log(sortArray([5, 1, 1, 2, 0, 0])) // 输出:[0, 0, 1, 1, 2, 5] -``` - -- **时间复杂度**:O(N log N),因为数组每次都被分成两部分,并且每次合并操作的时间复杂度为 O(N)。 -- **空间复杂度**:O(N),因为归并排序需要额外的空间来存储合并后的数组。 - -#### 最大子数组和 - -题目来源:[LeetCode #53 中等](https://leetcode.cn/problems/maximum-subarray/description/) - -给你一个整数数组 `nums`,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。 - -子数组是数组中的一个连续部分。 - -示例 1: -> 输入:nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4] -> 输出:6 -> 解释:连续子数组 [4, -1, 2, 1] 的和最大,为 6。 - -示例 2: -> 输入:nums = [1] -> 输出:1 - -示例 3: -> 输入:nums = [5, 4, -1, 7, 8] -> 输出:23 - -解决最大子数组和问题,分而治之的思想是一种有效的方法。分而治之的基本思想是将问题分解成子问题,分别解决这些子问题,然后合并这些子问题的解来得到原问题的解。在这个问题中,我们将数组分成两个部分,然后递归地求解左右两部分的最大子数组和,并合并两部分的结果。 - -解题步骤: - -1. **递归终止条件**:当数组长度为 1 时,返回数组的唯一元素。 -2. **分解数组**:找到数组的中点,将数组分成左右两部分。 -3. **递归求解**:递归地计算左半部分和右半部分的最大子数组和。 -4. **合并**:计算跨越中间的最大子数组和,包括: - - 从中点向左扫描的最大子数组和。 - - 从中点向右扫描的最大子数组和。 - - 跨越中点的最大子数组和等于左半部分的最大和加上右半部分的最大和。 - -代码实现: - -```javascript -function maxSubArray(nums) { - // 分治法求解最大子数组和 - return divideAndConquer(nums, 0, nums.length - 1) -} - -function divideAndConquer(nums, left, right) { - // 基本情况:如果只有一个元素,返回该元素 - if (left === right) { - return nums[left] - } - - // 计算中间点 - const mid = Math.floor((left + right) / 2) - - // 递归求解左半部分和右半部分的最大子数组和 - const leftMax = divideAndConquer(nums, left, mid) - const rightMax = divideAndConquer(nums, mid + 1, right) - - // 计算跨越中间点的最大子数组和 - const crossMax = maxCrossingSubArray(nums, left, mid, right) - - // 返回三个部分中最大的值 - return Math.max(leftMax, rightMax, crossMax) -} - -function maxCrossingSubArray(nums, left, mid, right) { - // 计算左半部分的最大子数组和 - let leftSum = -Infinity - let sum = 0 - for (let i = mid; i>= left; i--) { - sum += nums[i] - if (sum> leftSum) { - leftSum = sum - } - } - - // 计算右半部分的最大子数组和 - let rightSum = -Infinity - sum = 0 - for (let i = mid + 1; i <= right; i++) { - sum += nums[i] - if (sum> rightSum) { - rightSum = sum - } - } - - // 返回跨越中间点的最大子数组和 - return leftSum + rightSum -} - -// 示例测试 -console.log(maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4])) // 输出:6 -console.log(maxSubArray([1])) // 输出:1 -console.log(maxSubArray([5, 4, -1, 7, 8])) // 输出:23 -``` - -- **时间复杂度**:O(n log n):每次分治将问题分成两个子问题,类似于归并排序,每次合并时需要线性的时间来计算跨越中间的最大子数组和。 -- **空间复杂度**:O(log n):递归调用的深度为 log n,因此空间复杂度为 O(log n)(不包括输入和输出所占用的空间)。 - -#### 数组中的第 K 个最大元素 - -题目来源:[LeetCode #215 中等](https://leetcode.cn/problems/kth-largest-element-in-an-array/description) - -给定整数数组 `nums` 和整数 `k`,请返回数组中第 `k` 个最大的元素。 - -请注意,你需要找的是数组排序后的第 `k` 个最大的元素,而不是第 `k` 个不同的元素。 - -你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。 - -示例 1: -> 输入: [3, 2, 1, 5, 6, 4], k = 2 -> 输出:5 - -示例 2: -> 输入: [3, 2, 3, 1, 2, 4, 5, 5, 6], k = 4 -> 输出:4 - -为了找到数组中的第 `k` 个最大元素,并且实现时间复杂度为 O(n) 的算法,我们可以使用**快速选择算法(Quickselect)**。快速选择算法是快速排序的变种,通过分而治之的方法来选择特定的第 `k` 个元素。 - -解题步骤: - -1. **选择一个主元(pivot)**:通常选择数组的最后一个元素作为主元。 -2. **分区**:使用 Lomuto 分区方案,将数组重新排列,使得主元的位置是其最终位置,同时确保左边的元素都小于等于主元,右边的元素都大于主元。 -3. **递归搜索**: - - 如果主元的位置正好是我们需要找的位置,直接返回主元。 - - 如果主元的位置大于目标位置,在左半部分继续搜索。 - - 如果主元的位置小于目标位置,在右半部分继续搜索。 - -代码实现: - -```javascript -function findKthLargest(nums, k) { - // 目标是找到第 k 大的元素,即排序后第 (n-k) 小的元素 - const targetIndex = nums.length - k; - return quickSelect(nums, 0, nums.length - 1, targetIndex); -} - -function quickSelect(nums, left, right, targetIndex) { - if (left === right) { - return nums[left]; - } - - // 分区操作 - const pivotIndex = partition(nums, left, right); - - if (pivotIndex === targetIndex) { - return nums[pivotIndex]; - } else if (pivotIndex < targetIndex) { - return quickSelect(nums, pivotIndex + 1, right, targetIndex); - } else { - return quickSelect(nums, left, pivotIndex - 1, targetIndex); - } -} - -function partition(nums, left, right) { - const pivot = nums[right]; - let i = left; - - for (let j = left; j < right; j++) { - if (nums[j] <= pivot) { - [nums[i], nums[j]] = [nums[j], nums[i]]; - i++; - } - } - - [nums[i], nums[right]] = [nums[right], nums[i]]; - return i; -} - -// 示例测试 -console.log(findKthLargest([3, 2, 1, 5, 6, 4], 2)); // 输出:5 -console.log(findKthLargest([3, 2, 3, 1, 2, 4, 5, 5, 6], 4)); // 输出:4 -``` - -- **时间复杂度**:平均情况为 O(n),因为每次分区都会将数组分成两部分。然而,在最坏情况下(例如数组已经有序时),时间复杂度可能达到 O(n^2)。 -- **空间复杂度**:O(1),因为快速选择是就地排序的算法,不需要额外的空间来存储数组。递归调用的栈空间为 O(log n)。 - -## 动态规划 - -动态规划是一种解决复杂问题的方法,通过将问题分解成更小的子问题,**并利用子问题的重叠性,避免重复计算**,从而提高效率。动态规划的核心思想是利用已计算的结果来构建解决方案,从而减少不必要的计算。 - -### 基本步骤 - -1. **定义子问题**:将原问题分解为若干子问题,确定这些子问题的状态和状态之间的转移关系。 -2. **确定状态转移方程**:根据子问题的定义,找出当前状态与之前状态的关系,即状态转移方程。 -3. **初始化**:确定初始状态的值。 -4. **填表计算**:利用状态转移方程,从初始状态出发,逐步计算每个子问题的值,通常使用一个表格(数组)来存储子问题的解。 -5. **返回结果**:根据问题的要求,从表格中提取最终的结果。 - -### 使用场景 - -动态规划主要用于解决以下几类问题: -- **最优化问题**:如最短路径、最大子序列和等问题。 -- **计数问题**:如统计符合某些条件的方案数量。 -- **序列问题**:如最长递增子序列、最长公共子序列等问题。 -- **划分问题**:如背包问题、划分等问题。 - -### 动态规划的应用 - -#### 爬楼梯 - -题目来源:[LeetCode #70 简单](https://leetcode.cn/problems/climbing-stairs/) - -假设你正在爬楼梯。需要 `n` 阶你才能到达楼顶。 -每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢? - -示例 1: -> 输入:n = 2 -> 输出:2 -> 解释:有两种方法可以爬到楼顶。 -> -> 1. 1 阶 + 1 阶 -> 2. 2 阶 - -示例 2: -> 输入:n = 3 -> 输出:3 -> 解释:有三种方法可以爬到楼顶。 -> 1. 1 阶 + 1 阶 + 1 阶 -> 2. 1 阶 + 2 阶 -> 3. 2 阶 + 1 阶 - -解题步骤: - -1. **定义状态**:定义一个数组 `dp`,其中 `dp[i]` 表示达到第 `i` 阶的方法总数。 -2. **初始条件**:知道 `dp[0] = 1`(到达第 0 阶的方法是站在原地)和 `dp[1] = 1`(到达第 1 阶的方法只有一种)。 -3. **状态转移方程**:为了到达第 `i` 阶,可以从第 `i-1` 阶迈一步或者从第 `i-2` 阶迈两步,所以 `dp[i] = dp[i-1] + dp[i-2]`。 -4. **最终结果**:`dp[n]` 表示达到第 `n` 阶的方法总数。 - -代码实现: - -```javascript -function climbStairs(n) { - // 如果楼梯阶数为 0 或 1,直接返回 n - if (n <= 1) return n - - // 创建一个 dp 数组来存储每个台阶的方法数 - const dp = new Array(n + 1).fill(0) - - // 初始条件 - dp[0] = 1 - dp[1] = 1 - - // 计算每个台阶的方法数 - for (let i = 2; i <= n; i++) { - dp[i] = dp[i - 1] + dp[i - 2] - } - - // 返回到达第 n 阶的方法总数 - return dp[n] -} - -// 示例测试 -console.log(climbStairs(2)) // 输出:2 -console.log(climbStairs(3)) // 输出:3 -console.log(climbStairs(4)) // 输出:5 -console.log(climbStairs(5)) // 输出:8 -``` - -- **时间复杂度**:O(n),因为只需遍历一次数组。 -- **空间复杂度**:O(n),需要一个长度为 `n+1` 的数组来存储每一阶的方法数。 - -#### 最长递增子序列 - -题目来源:[LeetCode #300 中等](https://leetcode.cn/problems/longest-increasing-subsequence/description/) - -给你一个整数数组 `nums`,找到其中最长严格递增子序列的长度。 - -**子序列**是由数组派生而来的序列,删除(或不删除)数组中的元素而不改变其余元素的顺序。例如,`[3, 6, 2, 7]` 是数组 `[0, 3, 1, 6, 2, 2, 7]` 的子序列。 - -示例 1: -> 输入:nums = [10, 9, 2, 5, 3, 7, 101, 18] -> 输出:4 -> 解释:最长递增子序列是 [2, 3, 7, 101],因此长度为 4。 - -示例 2: -> 输入:nums = [0, 1, 0, 3, 2, 3] -> 输出:4 - -示例 3: -> 输入:nums = [7, 7, 7, 7, 7, 7, 7] -> 输出:1 - -解题步骤: - -1. **定义状态**:定义一个数组 `dp`,其中 `dp[i]` 表示以 `nums[i]` 结尾的最长递增子序列的长度。 -2. **初始化**:每个位置的初始值为 1,因为每个位置都至少可以是一个长度为 1 的子序列。 -3. **状态转移方程**:对于每个 `nums[i]`,遍历其之前的元素 `nums[j]` (0 ≤ j < i),如果 `nums[i]> nums[j]`,则更新 `dp[i] = max(dp[i], dp[j] + 1)`,表示在 `nums[j]` 的子序列上追加 `nums[i]`。 -4. **最终结果**:数组 `dp` 中的最大值即为最长递增子序列的长度。 - -代码实现: - -```javascript -function lengthOfLIS(nums) { - if (nums.length === 0) return 0 - - // dp 数组,每个位置初始化为 1 - const dp = new Array(nums.length).fill(1) - - // 计算每个位置的最长递增子序列长度 - for (let i = 1; i < nums.length; i++) { - for (let j = 0; j < i; j++) { - if (nums[i]> nums[j]) { - dp[i] = Math.max(dp[i], dp[j] + 1) - } - } - } - - // 返回 dp 数组中的最大值 - return Math.max(...dp) -} - -// 示例测试 -console.log(lengthOfLIS([10, 9, 2, 5, 3, 7, 101, 18])) // 输出:4 -console.log(lengthOfLIS([0, 1, 0, 3, 2, 3])) // 输出:4 -console.log(lengthOfLIS([7, 7, 7, 7, 7, 7, 7])) // 输出:1 -``` - -- **时间复杂度**:O(n^2),因为我们需要嵌套循环遍历每个元素对。 -- **空间复杂度**:O(n),需要一个长度为 `n` 的数组来存储每个位置的最长子序列长度。 - -#### 打家劫舍 - -题目来源:[LeetCode #198 中等](https://leetcode.cn/problems/house-robber/description/) - -你是一个专业的小偷,计划偷窃沿街的房屋。每间房内都藏有一定的现金,影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统,如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警。 - -给定一个代表每个房屋存放金额的非负整数数组,计算你不触动警报装置的情况下,一夜之内能够偷窃到的最高金额。 - -示例 1: -> 输入:[1, 2, 3, 1] -> 输出:4 -> 解释:偷窃 1 号房屋 (金额 = 1) ,然后偷窃 3 号房屋 (金额 = 3)。 -> 偷窃到的最高金额 = 1 + 3 = 4。 - -示例 2: -> 输入:[2, 7, 9, 3, 1] -> 输出:12 -> 解释:偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9),接着偷窃 5 号房屋 (金额 = 1)。 -> 偷窃到的最高金额 = 2 + 9 + 1 = 12。 - -解题步骤: - -1. **定义状态**:定义一个数组 `dp`,其中 `dp[i]` 表示到达第 `i` 个房子时可以偷窃到的最高金额。 -2. **初始条件**:如果只有一个房子,那么可以偷窃的最高金额就是该房子的金额,即 `dp[0] = nums[0]`。如果有两个房子,则可以偷窃的最高金额是这两个房子中金额较大的那个,即 `dp[1] = Math.max(nums[0], nums[1])`。 -3. **状态转移方程**:对于每个房子 `i`,有两种选择:偷窃该房子(然后加上 `i-2` 房子的最高金额)或者不偷窃该房子(直接取 `i-1` 房子的最高金额)。状态转移方程为 `dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i])`。 -4. **最终结果**:数组 `dp` 中的最后一个值即为可以偷窃到的最高金额。 - -代码实现: - -```javascript -function rob(nums) { - const n = nums.length - if (n === 0) return 0 - if (n === 1) return nums[0] - - // dp 数组,每个位置初始化为 0 - const dp = new Array(n).fill(0) - - // 初始条件 - dp[0] = nums[0] - dp[1] = Math.max(nums[0], nums[1]) - - // 填充 dp 数组 - for (let i = 2; i < n; i++) { - dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]) - } - - // 返回 dp 数组的最后一个值 - return dp[n - 1] -} - -// 示例测试 -console.log(rob([1, 2, 3, 1])) // 输出:4 -console.log(rob([2, 7, 9, 3, 1])) // 输出:12 -``` - -- **时间复杂度**:O(n),因为需要遍历一次数组。 -- **空间复杂度**:O(n),因为需要一个长度为 `n` 的数组来存储每个位置的最高金额。 - -优化空间复杂度: - -注意到我们在状态转移时,只需要前两个状态的值,所以可以将空间复杂度优化为 O(1)。 - -```javascript -function rob(nums) { - const n = nums.length - if (n === 0) return 0 - if (n === 1) return nums[0] - - let prev1 = 0 - let prev2 = 0 - - for (let i = 0; i < n; i++) { - const current = Math.max(prev1, prev2 + nums[i]) - prev2 = prev1 - prev1 = current - } - - return prev1 -} - -// 示例测试 -console.log(rob([1, 2, 3, 1])) // 输出:4 -console.log(rob([2, 7, 9, 3, 1])) // 输出:12 -``` - -优化后的算法分析: - -- **时间复杂度**:O(n),因为需要遍历一次数组。 -- **空间复杂度**:O(1),因为只需要常量空间来存储前两个状态的值。 - -通过上述方法,我们可以有效地计算出不触动警报装置的情况下,可以偷窃到的最高金额。优化后的代码在空间复杂度上更高效。 - -#### 零钱兑换 - -题目来源:[LeetCode #322 中等](https://leetcode.cn/problems/coin-change/description/) - -给你一个整数数组 `coins`,表示不同面额的硬币;以及一个整数 `amount`,表示总金额。 - -计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额,返回 `-1`。 - -你可以认为每种硬币的数量是无限的。 - -示例 1: -> 输入:coins = [1, 2, 5], amount = 11 -> 输出:3 -> 解释:11 = 5 + 5 + 1 - -示例 2: -> 输入:coins = [2], amount = 3 -> 输出:-1 - -示例 3: -> 输入:coins = [1], amount = 0 -> 输出:0 - -解题步骤: - -1. **定义状态**:定义一个数组 `dp`,其中 `dp[i]` 表示凑成金额 `i` 所需的最少硬币个数。 -2. **初始化**:`dp[0] = 0`,因为凑成金额 `0` 所需的硬币数是 `0`。其他 `dp[i]` 初始化为一个较大的值(如 `Infinity`),表示还没有计算出结果。 -3. **状态转移方程**:对于每个金额 `i`,尝试使用每种硬币 `coin`,更新 `dp[i] = Math.min(dp[i], dp[i - coin] + 1)`,表示从金额 `i - coin` 加上一个 `coin` 的硬币数量。 -4. **最终结果**:如果 `dp[amount]` 仍然是初始值 `Infinity`,则表示无法凑成该金额,返回 `-1`,否则返回 `dp[amount]`。 - -代码实现: - -```javascript -function coinChange(coins, amount) { - // 创建一个 dp 数组,初始化为 Infinity - const dp = new Array(amount + 1).fill(Infinity) - dp[0] = 0 // 初始化金额为 0 时的最少硬币数为 0 - - // 填充 dp 数组 - for (let i = 1; i <= amount; i++) { - for (const coin of coins) { - if (i - coin>= 0) { - dp[i] = Math.min(dp[i], dp[i - coin] + 1) - } - } - } - - // 如果 dp[amount] 还是 Infinity,表示无法凑成该金额,返回 -1 - return dp[amount] === Infinity ? -1 : dp[amount] -} - -// 示例测试 -console.log(coinChange([1, 2, 5], 11)) // 输出:3 -console.log(coinChange([2], 3)) // 输出:-1 -console.log(coinChange([1], 0)) // 输出:0 -console.log(coinChange([1, 3, 4, 5], 7)) // 输出:2 (3 + 4) -console.log(coinChange([2, 5, 10, 1], 27)) // 输出:4 (10 + 10 + 5 + 2) -``` - -- **时间复杂度**:O(n * m),其中 `n` 是金额 `amount`,`m` 是硬币种类数。 -- **空间复杂度**:O(n),需要一个长度为 `amount + 1` 的数组来存储每个金额的最少硬币数。 - -## 贪心算法 - -贪心算法是一种在每一步选择中都采取在当前状态下最好或最优的选择,从而希望导致结果是全局最优的算法。贪心算法的核心是贪心选择性质,即**每一步的局部最优选择最终能够导致全局最优解**。 - -### 基本步骤 - -1. **建立数学模型**:将问题抽象为数学模型,明确所需的解和约束条件。 -2. **选择贪心策略**:根据问题的特性,选择一个贪心策略,即在每一步选择中,采取局部最优的选择。 -3. **证明贪心选择的正确性**:证明所选的贪心策略能够得到问题的最优解,通常通过数学归纳法或反证法证明。 -4. **实施贪心算法**:从初始状态开始,按照贪心策略逐步推进,直到达到问题的约束条件或无法继续推进为止。 -5. **构造解**:根据选择的步骤,构造出问题的解。 - -### 使用场景 - -贪心算法通常用于以下几类问题: -- **最优化问题**:如最小生成树、最短路径等问题。 -- **活动选择问题**:如区间调度、任务安排等问题。 -- **资源分配问题**:如背包问题的某些变种、最大子序列和等问题。 -- **图论问题**:如 Dijkstra 算法求最短路径,Kruskal 算法和 Prim 算法求最小生成树。 - -### 贪心算法的应用 - -#### 分发饼干 - -题目来源:[LeetCode #455 简单](https://leetcode.cn/problems/assign-cookies/description/) - -假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。 - -对每个孩子 `i`,都有一个胃口值 `g[i]`,这是能让孩子们满足胃口的饼干的最小尺寸;并且每块饼干 `j`,都有一个尺寸 `s[j]`。如果 `s[j]>= g[i]`,我们可以将这个饼干 `j` 分配给孩子 `i`,这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子,并输出这个最大数值。 - -示例 1: -> 输入: g = [1, 2, 3], s = [1, 1] -> 输出:1 -> 解释: -> 你有三个孩子和两块小饼干,3 个孩子的胃口值分别是:1, 2, 3。 -> 虽然你有两块小饼干,由于他们的尺寸都是 1,你只能让胃口值是 1 的孩子满足。 -> 所以你应该输出 1。 - -示例 2: -> 输入: g = [1, 2], s = [1, 2, 3] -> 输出:2 -> 解释: -> 你有两个孩子和三块小饼干,2 个孩子的胃口值分别是 1, 2。 -> 你拥有的饼干数量和尺寸都足以让所有孩子满足。 -> 所以你应该输出 2。 - -先对孩子的满足度和饼干的大小排序,然后依次为每个孩子分配满足其满足度的最小饼干。 - -解题步骤: - -1. **排序**:将孩子的胃口数组 `g` 和饼干尺寸数组 `s` 分别进行排序。 -2. **匹配**:使用两个指针,一个指向孩子的胃口数组,另一个指向饼干尺寸数组。依次尝试用当前最小的饼干去满足当前最小的胃口。 -3. **更新指针**:如果当前饼干可以满足当前孩子的胃口,两个指针都移动到下一个。如果不能,则只移动饼干的指针,尝试用下一个较大的饼干去满足当前孩子的胃口。 -4. **结束条件**:当两个指针都到达数组末尾时,匹配结束,返回满足孩子的数量。 - -代码实现: - -```javascript -function findContentChildren(g, s) { - // 对孩子的胃口数组和饼干尺寸数组进行排序 - g.sort((a, b) => a - b) - s.sort((a, b) => a - b) - - let i = 0 // 孩子的指针 - let j = 0 // 饼干的指针 - let count = 0 // 满足的孩子数量 - - // 当孩子和饼干都没有处理完时进行匹配 - while (i < g.length && j < s.length) { - if (s[j]>= g[i]) { - // 当前饼干可以满足当前孩子 - count++ - i++ - } - // 无论是否满足,都尝试下一个饼干 - j++ - } - - return count -} - -// 示例测试 -console.log(findContentChildren([1, 2, 3], [1, 1])) // 输出:1 -console.log(findContentChildren([1, 2], [1, 2, 3])) // 输出:2 -console.log(findContentChildren([1, 2, 3], [3])) // 输出:1 -console.log(findContentChildren([10, 9, 8, 7], [5, 6, 7, 8])) // 输出:2 -``` - -- **时间复杂度**:O(n log n + m log m),其中 `n` 是孩子数组的长度,`m` 是饼干数组的长度。这是因为排序需要 O(n log n) 和 O(m log m)。 -- **空间复杂度**:O(1),只需要常量级别的额外空间。 - -#### 柠檬水找零 - -题目来源:[LeetCode #860 简单](https://leetcode.cn/problems/lemonade-change/description/) - -在柠檬水摊上,每一杯柠檬水的售价为 `5` 美元。顾客排队购买你的产品(按账单 `bills` 支付的顺序)一次购买一杯。 - -每位顾客只买一杯柠檬水,然后向你付 `5` 美元、`10` 美元或 `20` 美元。你必须给每个顾客正确找零,也就是说净交易是每位顾客向你支付 `5` 美元。 - -注意,一开始你手头没有任何零钱。 - -给你一个整数数组 `bills`,其中 `bills[i]` 是第 `i` 位顾客付的账。如果你能给每位顾客正确找零,返回 `true`,否则返回 `false`。 - -示例 1: -> 输入:bills = [5, 5, 5, 10, 20] -> 输出:true -> 解释: -> 前 3 位顾客那里,我们按顺序收取 3 张 5 美元的钞票。 -> 第 4 位顾客那里,我们收取一张 10 美元的钞票,并返还 5 美元。 -> 第 5 位顾客那里,我们找还一张 10 美元的钞票和一张 5 美元的钞票。 -> 由于所有客户都得到了正确的找零,所以我们输出 true。 - -示例 2: -> 输入:bills = [5, 5, 10, 10, 20] -> 输出:false -> 解释: -> 前 2 位顾客那里,我们按顺序收取 2 张 5 美元的钞票。 -> 对于接下来的 2 位顾客,我们收取一张 10 美元的钞票,然后返还 5 美元。 -> 对于最后一位顾客,我们无法退回 15 美元,因为我们现在只有两张 10 美元的钞票。 -> 由于不是每位顾客都得到了正确的找零,所以答案是 false。 - -遍历顾客给的钱,优先使用手中的大额钞票找零,从而保留小额钞票以应对后续的找零需求。 - -解题步骤: - -1. **初始化钱箱**:使用两个变量 `five` 和 `ten` 来分别表示手中拥有的 5 美元和 10 美元的数量,初始值为 0。 -2. **遍历账单**:遍历顾客付的每一张账单。 -3. **处理账单**: - - 如果顾客付的是 5 美元,直接收下。 - - 如果顾客付的是 10 美元,需要找零,检查是否有足够的 5 美元找零,如果有则找零,否则无法找零,返回 false。 - - 如果顾客付的是 20 美元,需要找零,优先使用 10 美元找零,然后再用 5 美元找零,如果都无法找零,则返回 false。 -4. **返回结果**:遍历结束后,如果能够给每个顾客正确找零,则返回 true,否则返回 false。 - -代码实现: - -```javascript -function lemonadeChange(bills) { - let five = 0 - let ten = 0 - - for (const bill of bills) { - if (bill === 5) { - // 顾客付 5 美元,直接收下 - five++ - } else if (bill === 10) { - // 顾客付 10 美元,尝试找零,优先使用 10 美元找零 - if (five === 0) { - return false // 无法找零,返回 false - } - five-- - ten++ - } else { - // 顾客付 20 美元,尝试找零,优先使用 10 美元找零,再使用 5 美元找零 - if (ten> 0 && five> 0) { - ten-- - five-- - } else if (five>= 3) { - five -= 3 - } else { - return false // 无法找零,返回 false - } - } - } - - return true -} - -// 示例测试 -console.log(lemonadeChange([5, 5, 5, 10, 20])) // 输出:true -console.log(lemonadeChange([5, 5, 10, 10, 20])) // 输出:false -``` - -- **时间复杂度**:O(n),其中 n 是账单的数量,我们需要遍历一次账单数组。 -- **空间复杂度**:O(1),只需要常数级别的额外空间来存储 5 美元和 10 美元的数量。 - -#### 跳跃游戏 - -题目来源:[LeetCode #55 中等](https://leetcode.cn/problems/jump-game/description/) - -给你一个非负整数数组 `nums`,你最初位于数组的第一个下标。数组中的每个元素代表你在该位置可以跳跃的最大长度。 - -判断你是否能够到达最后一个下标,如果可以,返回 `true`;否则,返回 `false`。 - -示例 1: -> 输入:nums = [2, 3, 1, 1, 4] -> 输出:true -> 解释:可以先跳 1 步,从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。 - -示例 2: -> 输入:nums = [3, 2, 1, 0, 4] -> 输出:false -> 解释:无论怎样,总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0,所以永远不可能到达最后一个下标。 - -从前往后遍历数组,维护当前能够到达的最远位置,如果在某一步能够到达或超过数组的最后一个位置,则返回 `true`。 - -解题步骤: - -1. **初始化**:定义一个变量 `maxReach`,表示当前能够到达的最远位置,初始值为 `0`。 -2. **遍历数组**:从头到尾遍历数组的每个位置,检查当前位置是否能够到达。如果当前位置大于 `maxReach`,说明不能到达当前位置,返回 `false`。 -3. **更新最远可达位置**:如果当前位置在可达范围内,更新 `maxReach` 为 `max(maxReach, i + nums[i])`。 -4. **检查是否可达**:如果在遍历过程中,`maxReach` 大于或等于数组的最后一个下标,返回 `true`。 - -代码实现: - -```javascript -function canJump(nums) { - let maxReach = 0 - - for (let i = 0; i < nums.length; i++) { - // 如果当前下标超过了能到达的最远位置 - if (i> maxReach) { - return false - } - // 更新能到达的最远位置 - maxReach = Math.max(maxReach, i + nums[i]) - // 如果能到达或超过最后一个下标 - if (maxReach>= nums.length - 1) { - return true - } - } - - return false -} - -// 示例测试 -console.log(canJump([2, 3, 1, 1, 4])) // 输出:true -console.log(canJump([3, 2, 1, 0, 4])) // 输出:false -console.log(canJump([0])) // 输出:true (只有一个元素,已经在最后一个下标) -console.log(canJump([2, 0])) // 输出:true (可以直接到达最后一个下标) -console.log(canJump([1, 2, 3, 4, 5])) // 输出:true (每步都能跳到最后) -``` - -1. **`canJump` 函数**:主函数,判断是否能够到达最后一个下标。 -2. **初始化 `maxReach`**:定义变量 `maxReach` 表示当前能够到达的最远位置,初始值为 `0`。 -3. **遍历数组**: - - 对于每个位置 `i`,检查是否超过了 `maxReach`。如果是,返回 `false`,表示不能到达该位置。 - - 否则,更新 `maxReach` 为 `max(maxReach, i + nums[i])`,表示当前能够到达的最远位置。 -4. **检查终止条件**:如果 `maxReach` 已经大于或等于数组的最后一个下标,返回 `true`。 -5. **返回结果**:遍历结束后,如果没有返回 `true`,则返回 `false`。 - -- **时间复杂度**:O(n),因为我们需要遍历一次数组。 -- **空间复杂度**:O(1),只需要常量级别的额外空间。 - -#### 无重叠区间 - -题目来源:[LeetCode #435 中等](https://leetcode.cn/problems/non-overlapping-intervals/description/) - -给定一个区间的集合 `intervals`,其中 `intervals[i] = [starti, endi]` 。返回需要移除区间的最小数量,使剩余区间互不重叠。 - -示例 1: -> 输入: intervals = [[1, 2], [2, 3], [3, 4], [1, 3]] -> 输出:1 -> 解释: 移除 [1, 3] 后,剩下的区间没有重叠。 - -示例 2: -> 输入: intervals = [[1, 2], [1,2], [1,2]] -> 输出:2 -> 解释: 你需要移除两个 [1, 2] 来使剩下的区间没有重叠。 - -示例 3: -> 输入: intervals = [[1, 2], [2, 3]] -> 输出:0 -> 解释:你不需要移除任何区间,因为它们已经是无重叠的了。 - -先按照区间的结束时间排序,然后依次选择结束时间最早且不与前一个选择的区间重叠的区间。对于这个问题,我们要尽可能多地保留区间,从而使得需要移除的区间数量最小。 - -解题步骤: - -1. **排序**:首先将区间按照结束时间 `end` 进行排序。这样可以保证每次选择的区间结束时间尽可能早,以便留出更多的空间给后面的区间。 -2. **贪心选择**:使用一个变量 `end` 来记录上一个选择的区间的结束时间。初始化 `end` 为负无穷大。 -3. **遍历区间**:依次遍历排序后的区间,如果当前区间的起始时间 `start` 大于等于 `end`,说明这个区间可以保留,同时更新 `end` 为当前区间的结束时间 `end`。否则,这个区间需要移除。 -4. **统计结果**:遍历结束后,计算需要移除的区间数量。 - -代码实现: - -```javascript -function eraseOverlapIntervals(intervals) { - if (intervals.length === 0) return 0 - - // 按区间的结束时间进行排序 - intervals.sort((a, b) => a[1] - b[1]) - - let count = 0 - let end = -Infinity - - for (const [start, finish] of intervals) { - if (start>= end) { - // 当前区间可以保留,更新结束时间 - end = finish - } else { - // 当前区间与上一个区间重叠,需要移除 - count++ - } - } - - return count -} - -// 示例测试 -console.log(eraseOverlapIntervals([[1, 2], [2, 3], [3, 4], [1, 3]])) // 输出:1 -console.log(eraseOverlapIntervals([[1, 2], [1, 2], [1, 2]])) // 输出:2 -console.log(eraseOverlapIntervals([[1, 2], [2, 3]])) // 输出:0 -console.log(eraseOverlapIntervals([[1, 2], [1, 3], [2, 4], [3, 5]])) // 输出:1 -console.log(eraseOverlapIntervals([[0, 2], [1, 3], [2, 4], [3, 5], [4, 6]])) // 输出:2 -``` -1. **`eraseOverlapIntervals` 函数**:主函数,计算需要移除的区间数量。 -2. **排序**:将区间按照结束时间进行排序,使得每次选择的区间结束时间尽可能早。 -3. **初始化变量**:`count` 用于记录需要移除的区间数量,`end` 初始化为负无穷大。 -4. **遍历区间**: - - 如果当前区间的起始时间 `start` 大于等于 `end`,说明这个区间可以保留,并更新 `end` 为当前区间的结束时间 `finish`。 - - 否则,这个区间与上一个区间重叠,需要移除,增加 `count` 计数器。 -5. **返回结果**:遍历结束后,返回需要移除的区间数量 `count`。 - -- **时间复杂度**:O(n log n),因为我们需要对区间进行排序。 -- **空间复杂度**:O(1),不需要额外的空间,除了用于存储输入的区间列表。 - -#### 分发糖果 - -题目来源:[LeetCode #135 困难](https://leetcode.cn/problems/candy/description/) - -`n` 个孩子站成一排。给你一个整数数组 `ratings` 表示每个孩子的评分。 - -你需要按照以下要求,给这些孩子分发糖果: - -- 每个孩子至少分配到 `1` 个糖果。 -- 相邻两个孩子评分更高的孩子会获得更多的糖果。 - -请你给每个孩子分发糖果,计算并返回需要准备的最少糖果数目。 - -示例 1: -> 输入:ratings = [1, 0, 2] -> 输出:5 -> 解释:你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。 - -示例 2: -> 输入:ratings = [1, 2, 2] -> 输出:4 -> 解释:你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。 -> 第三个孩子只得到 1 颗糖果,这满足题面中的两个条件。 - -先从左到右扫描数组,确保右边的评分更高的孩子获得更多糖果;再从右到左扫描数组,确保左边的评分更高的孩子获得更多糖果。 - -解题步骤: - -1. **初始化**:创建一个数组 `candies`,初始化每个孩子的糖果数为 1,表示每个孩子至少有一个糖果。 -2. **从左到右遍历**:检查每个孩子与前一个孩子的评分,如果当前孩子的评分比前一个孩子高,则更新当前孩子的糖果数为 `candies[i-1] + 1`。 -3. **从右到左遍历**:检查每个孩子与后一个孩子的评分,如果当前孩子的评分比后一个孩子高且糖果数不大于后一个孩子,则更新当前孩子的糖果数为 `candies[i+1] + 1`。 -4. **计算总糖果数**:遍历 `candies` 数组,求和得到最少需要的糖果数。 - -代码实现: - -```javascript -function candy(ratings) { - const n = ratings.length - const candies = new Array(n).fill(1) - - // 从左到右遍历,保证右边孩子评分高的糖果更多 - for (let i = 1; i < n; i++) { - if (ratings[i]> ratings[i - 1]) { - candies[i] = candies[i - 1] + 1 - } - } - - // 从右到左遍历,保证左边孩子评分高的糖果更多 - for (let i = n - 2; i>= 0; i--) { - if (ratings[i]> ratings[i + 1]) { - candies[i] = Math.max(candies[i], candies[i + 1] + 1) - } - } - - // 计算总糖果数 - return candies.reduce((sum, candy) => sum + candy, 0) -} - -// 示例测试 -console.log(candy([1, 0, 2])) // 输出:5 -console.log(candy([1, 2, 2])) // 输出:4 -console.log(candy([1, 3, 2, 2, 1])) // 输出:7 -console.log(candy([1, 2, 3, 4, 5])) // 输出:15 -console.log(candy([5, 4, 3, 2, 1])) // 输出:15 -``` - -1. **`candy` 函数**:主函数,计算最少需要的糖果数。 -2. **初始化 `candies` 数组**:每个孩子至少分配 1 个糖果。 -3. **从左到右遍历**: - - 如果当前孩子的评分高于前一个孩子,则当前孩子的糖果数等于前一个孩子的糖果数加 1。 -4. **从右到左遍历**: - - 如果当前孩子的评分高于后一个孩子且糖果数不大于后一个孩子,则更新当前孩子的糖果数为 `candies[i + 1] + 1`。 -5. **计算总糖果数**:通过遍历 `candies` 数组求和得到最少需要的糖果数。 - -- **时间复杂度**:O(n),因为我们需要遍历两次数组,每次遍历的时间复杂度都是 O(n)。 -- **空间复杂度**:O(n),因为我们需要额外的数组 `candies` 来存储每个孩子的糖果数。 - -## 回溯算法 - -回溯算法是一种通过逐步构建解决方案的方法,当遇到某一步无法继续前进时,回溯算法会回退到上一步,尝试其他的选择,直到找到问题的解决方案或确定无解。回溯算法通常通过深度优先搜索的方式实现。 - -### 基本步骤 - -1. **选择决策树**:将问题抽象成一个决策树,每个节点代表一个决策点。 -2. **深度优先搜索**:从根节点开始,采用深度优先搜索的方式探索决策树的所有分支。 -3. **做出选择**:在每个节点处,根据问题的限制条件,做出一个选择。 -4. **检查约束条件**:检查当前选择是否满足问题的约束条件,如果满足则继续探索,否则回溯到上一步。 -5. **标记路径**:在探索过程中,记录已经探索过的路径,避免重复探索。 -6. **撤销选择**:在回溯时,撤销当前节点的选择,回到上一层继续探索其他分支。 -7. **判断终止条件**:当到达叶子节点或者无法继续探索时,判断是否找到了问题的解决方案。 - -### 使用场景 - -回溯算法通常用于以下几类问题: -- **组合问题**:如组合总和、组合总和 II 等问题。 -- **排列问题**:如全排列、字符串的全排列等问题。 -- **搜索问题**:如解数独、N 皇后问题等。 -- **子集问题**:如子集、子集 II 等问题。 - -### 回溯算法的应用 - -#### 全排列 - -题目来源:[LeetCode #46 中等](https://leetcode.cn/problems/permutations/description/) - -给定一个不含重复数字的数组 `nums`,返回其所有可能的全排列。你可以按任意顺序返回答案。 - -示例 1: -> 输入:nums = [1, 2, 3] -> 输出:[[1, 2, 3], [1, 3, 2], [2, 1 ,3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] - -示例 2: -> 输入:nums = [0, 1] -> 输出:[[0, 1], [1, 0]] - -示例 3: -> 输入:nums = [1] -> 输出:[[1]] - -提示: -- `1 <= nums.length <= 6` -- `-10 <= nums[i] <= 10` -- `nums` 中的所有整数互不相同 - -解题步骤: - -1. **初始化结果集**:创建一个结果数组 `result` 来存储所有的排列。 -2. **回溯函数**:定义一个回溯函数 `backtrack`,参数为当前路径 `path` 和剩余可选择的数字 `choices`。 -3. **终止条件**:当路径长度等于输入数组长度时,表明我们找到了一种排列,将其加入结果集。 -4. **选择和探索**:遍历剩余可选择的数字,将每个数字加入当前路径,并递归调用回溯函数,传递更新后的路径和剩余可选择的数字。 -5. **回溯**:在递归调用结束后,撤销上一步选择,进行下一轮选择和探索。 - -代码实现: - -```javascript -function permute(nums) { - const result = [] - - function backtrack(path, choices) { - if (path.length === nums.length) { - result.push([...path]) - return - } - for (let i = 0; i < choices.length; i++) { - path.push(choices[i]) - backtrack(path, choices.slice(0, i).concat(choices.slice(i + 1))) - path.pop() - } - } - - backtrack([], nums) - return result -} - -// 示例测试 -console.log(permute([1, 2, 3])) // 输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] -console.log(permute([0, 1])) // 输出:[[0,1],[1,0]] -console.log(permute([1])) // 输出:[[1]] -``` - -1. **`permute` 函数**:主函数,接收输入数组 `nums`,返回所有的排列。 -2. **初始化结果集**:创建一个空数组 `result` 来存储所有的排列结果。 -3. **`backtrack` 函数**:递归函数,构建排列。参数 `path` 表示当前路径,`choices` 表示当前剩余的可选择数字。 -4. **终止条件**:当路径长度等于输入数组长度时,将当前路径加入结果集。 -5. **选择和探索**:遍历剩余可选择的数字,将每个数字加入当前路径,递归调用 `backtrack` 函数,并传递更新后的路径和剩余可选择的数字。 -6. **回溯**:在递归调用结束后,撤销上一步选择,通过 `path.pop()` 将最后一个元素移除,进行下一轮选择和探索。 - -- **时间复杂度**:O(n * n!),其中 n 是输入数组的长度。总共有 n! 种排列,每种排列需要 O(n) 的时间来构建。 -- **空间复杂度**:O(n),用于存储递归调用栈和临时路径。 - -#### 子集 - -题目来源:[LeetCode 78 中等](https://leetcode.cn/problems/subsets/description/) - -给你一个整数数组 `nums`,数组中的元素互不相同。返回该数组所有可能的子集(幂集)。 - -解集不能包含重复的子集。你可以按任意顺序返回解集。 - -示例 1: -> 输入:nums = [1, 2, 3] -> 输出:[[], [1], [2], [1,2], [3], [1, 3], [2, 3], [1, 2, 3]] - -示例 2: -> 输入:nums = [0] -> 输出:[[], [0]] - -提示: - -- `1 <= nums.length <= 10` -- `-10 <= nums[i] <= 10` -- `nums` 中的所有元素互不相同 - -解题步骤: - -1. **初始化结果集**:创建一个结果数组 `result` 来存储所有的子集。 -2. **回溯函数**:定义一个回溯函数 `backtrack`,参数为当前路径 `path` 和起始索引 `start`。 -3. **添加当前路径到结果集**:将当前路径 `path` 的拷贝加入结果集 `result`。 -4. **选择和探索**:从起始索引开始遍历 `nums` 数组,将每个数字加入当前路径,并递归调用回溯函数,传递更新后的路径和新的起始索引。 -5. **回溯**:在递归调用结束后,撤销上一步选择,进行下一轮选择和探索。 - -代码实现: - -```javascript -function subsets(nums) { - const result = [] - - function backtrack(path, start) { - // 将当前路径加入结果集 - result.push([...path]) - // 从当前索引开始遍历 nums 数组 - for (let i = start; i < nums.length; i++) { - // 将当前数字加入路径 - path.push(nums[i]) - // 递归调用回溯函数,传递更新后的路径和新的起始索引 - backtrack(path, i + 1) - // 回溯,撤销上一步选择 - path.pop() - } - } - - // 初始化回溯 - backtrack([], 0) - return result -} - -// 示例测试 -console.log(subsets([1, 2, 3])) // 输出:[[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]] -console.log(subsets([0])) // 输出:[[], [0]] -``` - -1. **`subsets` 函数**:主函数,接收输入数组 `nums`,返回所有的子集。 -2. **初始化结果集**:创建一个空数组 `result` 来存储所有的子集结果。 -3. **`backtrack` 函数**:递归函数,构建子集。参数 `path` 表示当前路径,`start` 表示起始索引。 -4. **添加当前路径到结果集**:将当前路径 `path` 的拷贝加入结果集 `result`。 -5. **选择和探索**:从起始索引开始遍历 `nums` 数组,将每个数字加入当前路径 `path`,递归调用 `backtrack` 函数,并传递更新后的路径和新的起始索引 `i + 1`。 -6. **回溯**:在递归调用结束后,撤销上一步选择,通过 `path.pop()` 将最后一个元素移除,进行下一轮选择和探索。 - -- **时间复杂度**:O(n * 2^n),其中 n 是输入数组的长度。总共有 2^n 个子集,每个子集的平均长度为 n/2。 -- **空间复杂度**:O(n),用于存储递归调用栈和临时路径。 - -#### 单词拆分 II - -题目来源:[LeetCode #140 困难](https://leetcode.cn/problems/word-break-ii/description/) - -给定一个字符串 `s` 和一个字符串字典 `wordDict`,在字符串 `s` 中增加空格来构建一个句子,使得句子中所有的单词都在词典中。以任意顺序返回所有这些可能的句子。 - -注意:词典中的同一个单词可能在分段中被重复使用多次。 - -示例 1: -> 输入:s = "catsanddog", wordDict = ["cat", "cats", "and", "sand", "dog"] -> 输出:["cats and dog", "cat sand dog"] - -示例 2: -> 输入:s = "pineapplepenapple", wordDict = ["apple", "pen", "applepen", "pine", "pineapple"] -> 输出:["pine apple pen apple", "pineapple pen apple", "pine applepen apple"] -> 解释:注意你可以重复使用字典中的单词。 - -示例 3: -> 输入:s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"] -> 输出:[] - -提示: -- `1 <= s.length <= 20` -- `1 <= wordDict.length <= 1000` -- `1 <= wordDict[i].length <= 10` -- `s` 和 `wordDict[i]` 仅有小写英文字母组成 -- `wordDict` 中所有字符串都不同 - -要解决这个问题,我们可以使用回溯算法结合动态规划进行优化。具体来说,我们需要递归地尝试在字符串 `s` 中插入空格来构成单词,同时使用缓存来存储已经计算过的结果,避免重复计算。 - -解题步骤: - -1. **定义缓存**:使用一个对象 `memo` 来存储已经计算过的子问题的结果。 -2. **定义回溯函数**:递归函数 `backtrack`,参数为当前子字符串 `s`。 -3. **递归终止条件**:如果当前子字符串 `s` 在缓存中,直接返回缓存中的结果;如果 `s` 为空字符串,返回包含一个空字符串的数组。 -4. **遍历匹配**:遍历词典中的单词,如果当前子字符串 `s` 以该单词开头,则递归处理剩余部分的字符串,并将结果组合起来。 -5. **更新缓存**:将当前子字符串的结果存入缓存中,并返回该结果。 - -代码实现: - -```javascript -function wordBreak(s, wordDict) { - const wordSet = new Set(wordDict) - const memo = {} - - function backtrack(s) { - // 如果当前子字符串已经在缓存中,直接返回缓存的结果 - if (memo[s] !== undefined) { - return memo[s] - } - // 如果子字符串为空,返回包含一个空字符串的数组 - if (s === '') { - return [''] - } - - const result = [] - - // 遍历词典中的每个单词 - for (const word of wordSet) { - if (s.startsWith(word)) { - const subResult = backtrack(s.slice(word.length)) - for (const sub of subResult) { - result.push(word + (sub === '' ? '' : ' ') + sub) - } - } - } - - // 将当前子字符串的结果存入缓存 - memo[s] = result - return result - } - - return backtrack(s) -} - -// 示例测试 -console.log(wordBreak('catsanddog', ['cat', 'cats', 'and', 'sand', 'dog'])) -// 输出:["cats and dog", "cat sand dog"] - -console.log(wordBreak('pineapplepenapple', ['apple', 'pen', 'applepen', 'pine', 'pineapple'])) -// 输出:["pine apple pen apple", "pineapple pen apple", "pine applepen apple"] - -console.log(wordBreak('catsandog', ['cats', 'dog', 'sand', 'and', 'cat'])) -// 输出:[] -``` - -1. **`wordBreak` 函数**:主函数,接收字符串 `s` 和词典 `wordDict`,返回所有可能的句子。 -2. **初始化**:将词典转化为集合 `wordSet`,用于快速查找;定义缓存 `memo`。 -3. **`backtrack` 函数**:递归函数,处理当前子字符串 `s`,返回其所有可能的句子组合。 -4. **缓存查询**:如果当前子字符串 `s` 在缓存中,直接返回缓存中的结果。 -5. **递归终止条件**:如果子字符串 `s` 为空,返回包含一个空字符串的数组。 -6. **遍历词典**:对于每个单词,如果当前子字符串 `s` 以该单词开头,则递归处理剩余部分的字符串 `s.slice(word.length)`。 -7. **组合结果**:将当前单词和递归结果组合成新的句子,并添加到结果集中。 -8. **更新缓存**:将当前子字符串 `s` 的结果存入缓存 `memo`,避免重复计算。 -9. **返回结果**:主函数调用 `backtrack` 函数,返回最终结果。 - - -- **时间复杂度**:最坏情况下为 O(n^2 * k),其中 n 是字符串 `s` 的长度,k 是词典 `wordDict` 的大小。每个子字符串的计算会涉及到对词典的遍历,并且需要组合结果。 -- **空间复杂度**:O(n^2),用于缓存子字符串的结果和存储递归栈。 - diff --git a/src/docs/algorithm/search.md b/src/docs/algorithm/search.md deleted file mode 100644 index be3ec23..0000000 --- a/src/docs/algorithm/search.md +++ /dev/null @@ -1,63 +0,0 @@ -# 搜索算法 - -搜索算法简单来说就是用于找出数组中某个元素的下标。 - -JavaScript 语言中的自带的搜索:数组的 `indexOf` 方法。 - -## 顺序搜索 - -顺序搜索(Sequential Search)算法是一种简单的搜索算法,它按顺序检查列表中的每个元素,直到找到目标元素或遍历完整个列表。 - -代码实现: - -```js -function sequentialSearch(array, target) { - // 遍历数组中的每个元素 - for (let i = 0; i < array.length; i++) { - // 如果当前元素等于目标元素,则返回当前元素的索引 - if (array[i] === target) { - return i - } - } - // 如果未找到目标元素,则返回 -1 - return -1 -} - -// 测试 -console.log(sequentialSearch([1, 2, 3, 4, 5], 0)) // -1 -console.log(sequentialSearch([1, 2, 3, 4, 5], 3)) // 2 -``` - -顺序搜索的时间复杂度为 O(n),其中 n 是列表的长度。 - -## 二分搜索 - -二分搜索(Binary Search)是一种高效的搜索算法,适用于有序数组。该算法通过重复将搜索范围缩小为一半来找到目标值。 - -```js -function binarySearch(arr, target) { - let low = 0 // 搜索范围的最低索引 - let high = arr.length - 1 // 搜索范围的最高索引 - - while (low <= high) { - const mid = Math.floor((low + high) / 2) // 中间索引 - - if (arr[mid] === target) { - return mid // 找到目标元素,返回索引 - } - if (arr[mid] < target) { - low = mid + 1 // 目标元素在右半部分,调整搜索范围的最低索引 - } else { - high = mid - 1 // 目标元素在左半部分,调整搜索范围的最高索引 - } - } - - return -1 // 目标元素未找到 -} - -// 测试 -console.log(binarySearch([1, 2, 3, 4, 5], 0)) // -1 -console.log(binarySearch([1, 2, 3, 4, 5], 3)) // 2 -``` - -二分搜索的时间复杂度为 O(log n),其中 n 是数组的长度。 diff --git a/src/docs/algorithm/sort.md b/src/docs/algorithm/sort.md deleted file mode 100644 index 7be7051..0000000 --- a/src/docs/algorithm/sort.md +++ /dev/null @@ -1,708 +0,0 @@ -# 排序算法 - -简单来说,排序算法用于将一组乱序的元素按照升序或降序的顺序重新排列。排序算法的性能通常通过其时间复杂度、空间复杂度、稳定性等指标来衡量。 - -JavaScript 语言中的自带的排序:数组的 `sort` 方法。 - -## 冒泡排序 - -冒泡排序(Bubble Sort)是一种简单的比较排序算法。它重复地遍历待排序数组,每次比较相邻的两个元素,如果顺序相反则进行交换。这样,每一轮遍历都会将最大(或最小)的元素"冒泡"到顶端,直到整个数组都排序完成,最终达到完全有序。 - -步骤: - -1. **遍历数组**:从头到尾遍历数组,比较相邻的两个元素。 -2. **比较相邻元素**:每次比较相邻的两个元素,如果它们的顺序不正确(比如,前一个元素大于后一个元素),则交换它们。 -3. **重复遍历**:重复上述步骤,直到没有任何一对元素需要交换,即数组已经完全排序。 - -代码实现: - -```js -function bubbleSort(array) { - // 检查输入是否为数组且长度大于 1,若不满足条件,则直接返回原数组 - if (!Array.isArray(array) || array.length <= 1) return array - - // 初始化最后一个未排序元素的索引 - let lastIndex = array.length - 1 - - // 当还有未排序的元素时,执行排序过程 - while (lastIndex> 0) { - // 初始化交换标志为 true,若本轮未发生交换,则排序完成 - let flag = true - // 记录最后一次交换元素的位置,初始设置为未排序部分的末尾 - const k = lastIndex - - // 遍历未排序部分的元素 - for (let j = 0; j < k; j++) { - // 若当前元素大于其后面的元素,则交换它们的位置 - if (array[j]> array[j + 1]) { - flag = false // 发生了交换,将标志设置为 false - lastIndex = j // 记录最后一次交换的位置 - ;[array[j], array[j + 1]] = [array[j + 1], array[j]] // 交换元素 - } - } - - // 若本轮未发生交换,则数组已经有序,直接退出循环 - if (flag) break - } - - // 返回排序后的数组 - return array -} - -// 测试 -console.log(bubbleSort([6,1,5,4,2,3])) // [1, 2, 3, 4, 5, 6] -``` - -冒泡排序有几种可以优化的空间: - -- **优化遍历范围**:在每一轮排序中,可以观察到最后一次交换发生的位置之后的元素已经是有序的,因此可以将下一轮排序的范围限定在上一轮最后一次交换的位置之前。这样可以减少不必要的比较和交换操作。 - -- **添加标志位**:如果在一轮排序过程中没有发生任何元素的交换,说明数组已经是有序的,可以提前结束排序过程。 - -- **针对部分有序数组的优化**:如果数组在初始状态下已经接近有序,可以记录下每轮排序中最后一次交换的位置,然后下一轮排序时只需要遍历到该位置即可,这样可以大大减少排序的比较次数。 - -- **鸡尾酒排序(双向冒泡排序)**:在一次排序过程中,既从左到右比较交换,又从右到左比较交换,可以在某些特定情况下提升效率。 - -时间复杂度: - -- **最优时间复杂度**:O(n) - 当输入数据已经是有序时,冒泡排序可以通过设置一个标志变量来检测是否发生了交换操作,如果在某一趟排序中没有交换操作发生,说明数组已经有序,因此可以提前结束排序过程。此时,最优时间复杂度为 O(n)。 - -- **最坏时间复杂度**:O(n^2) - 在最坏情况下,输入数据是逆序的,此时需要进行 n-1 趟排序,每一趟排序中需要进行的比较次数逐渐减少,总比较次数为 n(n-1)/2,因此最坏时间复杂度为 O(n^2)。 - -- **平均时间复杂度**:O(n^2) - 在一般情况下,冒泡排序的比较和交换操作的次数与输入数据的初始排列状态有关,但总体而言其时间复杂度仍为 O(n^2)。 - -空间复杂度: - -冒泡排序是一种**原地排序算法**,它在排序过程中只需要常数级的额外空间,即只使用了少量的辅助变量,因此其空间复杂度为 O(1)。 - -稳定性: - -冒泡排序是一种**稳定排序算法**。在排序过程中,如果两个相等的元素相互比较,它们不会交换位置,因此相等元素的相对位置不会改变。 - -冒泡排序由于其简单易懂的特性,常用于教学和小规模数据集的排序,但由于其较低的效率,通常不适合大规模数据集的排序任务。 - -## 选择排序 - -选择排序(Selection Sort)是一种简单的比较排序算法。它的基本思想是在未排序数组中找到最小(或最大)的元素,然后将其放置到数组的起始位置,接着在剩余的未排序部分中继续寻找最小(或最大)的元素,依次类推,直到所有元素都排序完成。 - -步骤: - -1. **初始状态:** 将整个序列看作两部分,一部分是未排序的,一部分是已排序的(初始时已排序部分为空)。 - -2. **遍历未排序部分:** 遍历未排序部分,找到最小(或最大)的元素。 - -3. **交换元素:** 将找到的最小(或最大)元素与未排序部分的第一个元素交换位置,使得找到的最小元素成为已排序部分的最后一个元素。 - -4. **扩大已排序部分:** 将已排序部分的长度增加 1,未排序部分的长度减少 1。 - -5. **重复:** 重复以上步骤,直到所有元素都已经排序完毕。 - -这个过程类似于每次从一堆未排序的卡片中选出最小(或最大)的卡片,然后放到已排序的卡片堆中。选择排序的特点是每次遍历都只进行一次交换操作,因此相对于其他排序算法,它的交换次数较少。 - -代码实现: - -```js -function selectionSort(array) { - // 获取数组长度 - const { length } = array - - // 如果不是数组或者数组长度小于等于 1,直接返回,不需要排序 - if (!Array.isArray(array) || length <= 1) return array - - // 外层循环,遍历整个数组,每次找到当前未排序部分的最小元素并放到已排序部分的末尾 - for (let i = 0; i < length - 1; i++) { - let minIndex = i // 设置当前循环最小元素索引 - - // 内层循环,从当前元素的下一个位置开始遍历,找到未排序部分的最小元素 - for (let j = i + 1; j < length; j++) { - // 如果当前元素比最小元素索引小,则更新最小元素索引 - if (array[minIndex]> array[j]) { - minIndex = j - } - } - - // 交换最小元素到当前位置 - swap(array, i, minIndex) - } - - return array -} - -// 交换数组中两个元素的位置 -function swap(array, left, right) { - const temp = array[left] - array[left] = array[right] - array[right] = temp -} - -// 测试 -console.log(selectionSort([6, 1, 5, 4, 2, 3])) // [1, 2, 3, 4, 5, 6] -``` - -时间复杂度: - -- **最优时间复杂度**:O(n^2) - 无论输入数据的初始排列状态如何,选择排序总是需要进行 n(n-1)/2 次比较,因此最优时间复杂度为 O(n^2)。 - -- **最坏时间复杂度**:O(n^2) - 同样地,在最坏情况下,选择排序仍需要进行 n(n-1)/2 次比较,所以最坏时间复杂度为 O(n^2)。 - -- **平均时间复杂度**:O(n^2) - 由于选择排序每一趟排序所需的比较次数固定,因此其平均时间复杂度也为 O(n^2)。 - -空间复杂度: - -选择排序是一种**原地排序算法**,只需要常数级的辅助空间(通常是用于交换元素的临时变量),因此其空间复杂度为 O(1)。 - -稳定性: - -选择排序通常**不是稳定排序**。在选择排序过程中,每次从未排序部分选择最小(或最大)元素并将其与未排序部分的第一个元素交换时,如果相等元素存在,原有的相对顺序可能会被打破。例如: - -- 初始数组:[3, 2, 2, 1] -- 第一次选择:选择最小元素 1,与第一个元素 3 交换,结果:[1, 2, 2, 3] -- 第二次选择:选择最小元素 2,与第二个元素 2 交换,结果:[1, 2, 2, 3] - -虽然这个例子没有改变相同元素的相对顺序,但在某些情况下,如处理:[2, 3, 1, 2],第二个"2"会被提前,与第一个"2"交换,导致顺序改变。 - -选择排序由于其简单性和恒定的空间复杂度,适用于对内存空间要求较高但对时间效率要求不高的场景。然而,由于其 O(n^2) 的时间复杂度,选择排序在处理大规模数据集时效率较低,通常不作为首选的排序算法。 - -## 插入排序 - -插入排序(Insertion Sort)是一种简单的比较排序算法。它的基本思想是将待排序数组分成**已排序**和**未排序**两部分,初始时已排序部分只有一个元素(即数组的第一个元素),然后从未排序部分依次取出元素,将其插入到已排序部分的正确位置,直到所有元素都被插入完成。 - -> 插入排序类似扑克牌思想,想象在打扑克牌,拿起来第一张,放哪里无所谓,再拿起来一张,比第一张小,放左边,继续拿,可能是中间数,就插在中间,依次把牌拿完。 - -步骤: - -1. **初始已排序部分**:初始时,将待排序数组的第一个元素视为已排序部分,其余元素视为未排序部分。 -2. **遍历未排序部分**:从第二个元素开始,依次遍历未排序部分的元素。 -3. **插入到已排序部分**:对于每个未排序部分的元素,将其与已排序部分的元素逐个比较,找到正确的插入位置。 -4. **重复插入**:将元素插入到已排序部分的正确位置后,已排序部分的长度增加 1,未排序部分的长度减少 1,继续重复上述步骤,直到所有元素都被插入完成。 - -代码实现: - -```js -function insertSort(array) { - const { length } = array - - // 如果不是数组或者数组长度小于等于 1,直接返回,不需要排序 - if (!Array.isArray(array) || length <= 1) return array - - // 循环从 1 开始,0 位置为默认的已排序的序列 - for (let i = 1; i < length; i++) { - const temp = array[i] // 保存当前需要排序的元素 - let j = i - - // 在当前已排序序列中比较,如果比需要排序的元素大,就依次往后移动位置 - while (j - 1>= 0 && array[j - 1]> temp) { - array[j] = array[j - 1] - j-- - } - - // 将找到的位置插入元素 - array[j] = temp - } - - return array -} - -insertSort([6,1,5,4,2,3]) // [1, 2, 3, 4, 5, 6] -``` - -时间复杂度: - -- **最优时间复杂度**:O(n) - 当输入数据已经有序时,插入排序每次只需要比较一次即可确定元素的位置,无需进行交换操作。此时,最优时间复杂度为 O(n)。 - -- **最坏时间复杂度**:O(n^2) - 在最坏情况下,输入数据是逆序的。此时,插入排序需要进行大量的比较和移动操作,每次插入元素时都需要将其与已经排序的部分进行比较并移动其他元素。因此最坏时间复杂度为 O(n^2)。 - -- **平均时间复杂度**:O(n^2) - 在一般情况下,插入排序的比较和移动操作次数与输入数据的初始排列状态有关,但总体而言,其平均时间复杂度为 O(n^2)。 - -空间复杂度: - -插入排序是一种**原地排序算法**,它在排序过程中只需要常数级的额外空间(用于存储待插入的元素的临时变量),因此其空间复杂度为 O(1)。 - -稳定性: - -插入排序是一种**稳定排序算法**。在插入过程中,如果待插入的元素与已排序部分的某个元素相等,插入排序会将待插入的元素放在相等元素的后面,从而保持相等元素的相对顺序不变。 - -插入排序由于其简单性和对小规模数据集的高效性,常用于对小型数组进行排序或在其他更复杂的排序算法(如快速排序、归并排序)的过程中处理小数据块。然而,由于其 O(n^2) 的时间复杂度,插入排序在处理大规模数据集时效率较低。 - -## 希尔排序 - -希尔排序(Shell Sort)是一种改进的插入排序算法,也被称为"缩小增量排序"。它的基本思想是通过定义一个间隔序列(称为增量序列),将待排序数组分成若干个子序列,对每个子序列进行插入排序。随着排序的进行,增量序列逐渐缩小,直到增量为 1,最后对整个数组进行插入排序。 - -步骤: - -1. **选择增量序列**:定义一个增量序列,确定每个增量值(间隔),通常以递减的方式选择。 -2. **分组排序**:将待排序数组根据当前增量值分成若干个子序列,对每个子序列进行插入排序。 -3. **逐步缩小增量**:重复上述步骤,逐步缩小增量值,直到增量为 1。 -4. **最终排序**:当增量为 1 时,对整个数组进行一次插入排序,完成排序过程。 - -代码实现: - -```js -function hillSort(array) { - const { length } = array - - // 如果输入不是数组或者数组长度小于等于 1,直接返回原数组,不需要排序 - if (!Array.isArray(array) || length <= 1) return array - - // 第一层循环:确定增量的大小,每次增量的大小减半 - for (let gap = parseInt(length>> 1); gap>= 1; gap = parseInt(gap>> 1)) { - // 对每个分组使用插入排序,相当于将插入排序的 1 换成了 gap - for (let i = gap; i < length; i++) { - const temp = array[i] // 保存当前元素 - let j = i - - // 第二层循环:对当前分组进行插入排序 - // 如果 j - gap>= 0 并且前一个元素大于当前元素,则进行交换 - while (j - gap>= 0 && array[j - gap]> temp) { - array[j] = array[j - gap] // 将前一个元素后移 - j -= gap // 继续比较下一个分组内的元素 - } - array[j] = temp // 插入元素到正确的位置 - } - } - - return array // 返回排序后的数组 -} - -hillSort([6,1,5,4,2,3]) // [1, 2, 3, 4, 5, 6] -``` - -时间复杂度: - -希尔排序的时间复杂度较为复杂,与所选的增量序列(gap sequence)有很大关系。常见的增量序列有希尔增量序列、Hibbard 增量序列、Sedgewick 增量序列等。以下是几种常见增量序列的时间复杂度分析: - -- **希尔增量序列**(gap = n/2, n/4, ..., 1):最坏时间复杂度:O(n^2) - -- **Hibbard 增量序列**(gap = 2^k - 1):最坏时间复杂度:O(n^(3/2)) - -- **Sedgewick 增量序列**(一种较为复杂的序列):最坏时间复杂度:O(n^(4/3)) - -- **更优的增量序列**:有些优化过的增量序列可以达到 O(n log^2 n) 的最坏时间复杂度。 - -由于增量序列的选择对希尔排序的时间复杂度有很大的影响,所以具体的时间复杂度因实现而异,但通常在 O(n^2) 和 O(n log^2 n) 之间。 - -空间复杂度: - -希尔排序是一种**原地排序算法**,其空间复杂度为 O(1),只需要常数级的额外空间。 - -稳定性: - -希尔排序**不是稳定排序**。在排序过程中,元素可能会跨越多个位置进行交换,因此相同元素的相对顺序可能会被打乱。 - -希尔排序由于其高效性和相对简单的实现,在实际应用中有一定的优势,特别是在数据规模较大时。它通过对插入排序的改进,大大减少了数据移动的次数,从而提高了排序的效率。 - -## 归并排序 - -归并排序(Merge Sort)是一种基于分治法(Divide and Conquer)的高效排序算法。其基本思想是将数组分成更小的子数组,分别对这些子数组进行排序,然后再将它们合并起来,以得到一个有序的数组。 - -步骤: - -1. **分割(Divide)**:将数组从中间分成两个子数组(递归地分割直到子数组的长度为 1)。 -2. **排序(Conquer)**:对每个子数组进行排序。因为子数组的长度为 1,所以它们是有序的。 -3. **合并(Combine)**:将两个有序的子数组合并成一个有序的数组。重复这个过程,直到所有的子数组被合并成一个完整的有序数组。 - - -代码实现: - -```js -function mergeSort(array) { - const { length } = array - - // 如果不是数组或者数组长度小于等于 0,直接返回,不需要排序 - if (!Array.isArray(array) || length <= 1) return array - - const mid = parseInt(length>> 1) // 找到中间索引值 - const left = array.slice(0, mid) // 截取左半部分 - const right = array.slice(mid, length) // 截取右半部分 - - return merge(mergeSort(left), mergeSort(right)) // 递归分解后,进行排序合并 -} - -function merge(leftArray, rightArray) { - const result = [] - const leftLength = leftArray.length - const rightLength = rightArray.length - let il = 0 - let ir = 0 - - // 左右两个数组的元素依次比较,将较小的元素加入结果数组中,直到其中一个数组的元素全部加入完则停止 - while (il < leftLength && ir < rightLength) { - if (leftArray[il] < rightArray[ir]) { - result.push(leftArray[il++]) - } else { - result.push(rightArray[ir++]) - } - } - - // 如果是左边数组还有剩余,则把剩余的元素全部加入到结果数组中。 - while (il < leftLength) { - result.push(leftArray[il++]) - } - - // 如果是右边数组还有剩余,则把剩余的元素全部加入到结果数组中。 - while (ir < rightLength) { - result.push(rightArray[ir++]) - } - - return result -} - -mergeSort([6,1,5,4,2,3]) // [1, 2, 3, 4, 5, 6] -``` - -基本过程: - -1. **分割**:将待排序数组分成两半。 -2. **递归排序**:对每一半分别进行递归排序。 -3. **合并**:合并两个有序子数组以形成一个有序的整体。 - -时间复杂度: - -1. **最优时间复杂度**:O(n log n) -2. **最坏时间复杂度**:O(n log n) -3. **平均时间复杂度**:O(n log n) - -归并排序在最优、最坏和平均情况下的时间复杂度都是 O(n log n),因为它始终将数组分成两半,然后对每一半进行排序,再合并结果。 - -空间复杂度: - -归并排序的空间复杂度为 O(n),这是因为归并排序在合并过程中需要一个额外的数组来暂存数据。对于递归实现,还需要考虑递归调用的栈空间,但总的额外空间仍然是 O(n)。 - -稳定性: - -归并排序是一种**稳定排序算法**。在合并两个有序子数组的过程中,如果两个元素相等,先将前一个数组的元素放入结果数组中,从而保持相等元素的相对顺序不变。 - -归并排序由于其稳定性和 O(n log n) 的时间复杂度,常用于处理大规模数据集,尤其是在需要稳定排序的情况下。虽然归并排序的空间复杂度较高,但其分治策略使其在许多应用中表现出色。 - -## 快速排序 - -快速排序(Quick Sort)是一种高效的排序算法,基于分治法(Divide and Conquer)。它通过选择一个"基准"(pivot)元素,并将数组分成两部分,其中一部分的所有元素都小于基准,另一部分的所有元素都大于基准。然后递归地对这两部分进行排序。 - -步骤: - -1. **选择基准**:从数组中选择一个元素作为基准(pivot)。 -2. **分区**:重新排列数组,使得所有小于基准的元素在基准的左边,所有大于基准的元素在基准的右边(相等的元素可以放在任一侧)。此时基准元素处于其正确的位置。 -3. **递归排序**:递归地对基准左边的子数组和右边的子数组进行排序。 - -代码实现: - -```js -function quickSort(array) { - // 如果不是数组或者数组长度小于等于 0,直接返回,不需要排序 - if (!Array.isArray(array) || array.length <= 1) return array - - // 选择基准 - const pivot = array[array.length - 1] - // 使用两个数组 left 和 right 来存储小于和大于基准的元素 - const left = [] - const right = [] - - // 分区过程 - for (let i = 0; i < array.length - 1; i++) { - if (array[i] < pivot) { - left.push(array[i]) - } else { - right.push(array[i]) - } - } - - // 递归地排序左右子数组并合并 - return [...quickSort(left), pivot, ...quickSort(right)] -} - -quickSort([6, 1, 5, 4, 2, 3]) // [1, 2, 3, 4, 5, 6] -``` - -时间复杂度: - -- **最优时间复杂度**:O(n log n) - 当每次划分的子数组都比较均匀时,递归树的高度为 log n,每层的操作复杂度为 O(n),所以最优时间复杂度为 O(n log n)。 - -- **最坏时间复杂度**:O(n^2) - 在最坏情况下,每次划分的子数组高度不均匀,例如每次选择的基准(pivot)是最大或最小元素,这会导致递归树退化为链表形式,时间复杂度为 O(n^2)。 - -- **平均时间复杂度**:O(n log n) - 在实际应用中,快速排序的平均性能通常很好,期望时间复杂度为 O(n log n),因为随机选择基准或使用"三数取中"等方法可以有效避免最坏情况。 - -空间复杂度: - -快速排序的空间复杂度主要取决于递归调用栈的深度: - -- **平均空间复杂度**:O(log n) - 在理想情况下,递归调用栈的深度为 log n,因此空间复杂度为 O(log n)。 - -- **最坏空间复杂度**:O(n) - 在最坏情况下,递归调用栈的深度为 n,因此空间复杂度为 O(n)。 - -稳定性: - -快速排序**不是稳定排序**。在排序过程中,元素的相对顺序可能会被改变,因为基准元素的交换可能会使得相等的元素顺序颠倒。 - -快速排序因其高效性和较好的平均性能,广泛应用于各种排序任务。通过随机选择基准或"三数取中"等方法,可以有效地改善其性能,避免最坏情况的发生。 - -## 堆排序 - -堆排序(Heap Sort)是一种基于二叉堆数据结构的比较排序算法。堆排序可以分为两个阶段:构建初始堆和在堆上进行排序操作。 - -步骤: - -1. **构建最大堆**:将无序数组构建成一个最大堆(max heap),最大堆是一个完全二叉树,其中每个节点的值都大于或等于其子节点的值。 -2. **排序**:交换堆顶元素(最大值)和堆的最后一个元素,并将堆的大小减少 1。然后对堆的根节点进行调整,使其重新成为最大堆。 - 重复上述步骤,直到堆中剩余元素只剩一个,即完成排序。 - -```js -function heapSort(array) { - // 如果不是数组或者数组长度小于等于 1,直接返回,不需要排序 - if (!Array.isArray(array) || array.length <= 1) return array - - const n = array.length - - // 构建最大堆 - for (let i = Math.floor(n / 2) - 1; i>= 0; i--) { - heapify(array, n, i) - } - - // 逐一从堆中取出元素,并对剩余元素重新堆化 - for (let i = n - 1; i> 0; i--) { - // 将堆顶(最大值)和堆的最后一个元素交换 - ;[array[0], array[i]] = [array[i], array[0]] - - // 对堆的剩余部分重新堆化 - heapify(array, i, 0) - } - - return array -} - -// 堆化函数,维护堆的性质 -function heapify(array, n, i) { - let largest = i // 假设当前节点是最大值 - const left = 2 * i + 1 // 左子节点 - const right = 2 * i + 2 // 右子节点 - - // 如果左子节点大于当前节点,则更新最大值 - if (left < n && array[left]> array[largest]) { - largest = left - } - - // 如果右子节点大于当前节点,则更新最大值 - if (right < n && array[right]> array[largest]) { - largest = right - } - - // 如果最大值不是当前节点,则交换并继续堆化 - if (largest !== i) { - ;[array[i], array[largest]] = [array[largest], array[i]] - heapify(array, n, largest) - } -} - -heapSort([6, 1, 5, 4, 2, 3]) // [1, 2, 3, 4, 5, 6] -``` - -堆排序(Heap Sort)是一种高效的排序算法,利用了堆数据结构的特性。以下是堆排序的时间复杂度、空间复杂度及其稳定性的详细分析: - -时间复杂度: - -- **最优时间复杂度**:O(n log n) - 在最优情况下,堆排序的时间复杂度为 O(n log n),因为构建最大堆和进行堆排序的时间复杂度都是 O(n log n)。 - -- **最坏时间复杂度**:O(n log n) - 在最坏情况下,堆排序的时间复杂度也是 O(n log n)。无论输入数据的顺序如何,都需要将数据构建成最大堆,然后进行排序。 - -- **平均时间复杂度**:O(n log n) - -空间复杂度: - -堆排序是一种**原地排序算法**,它只需要常数级别的额外空间来存储堆的数据结构,因此其空间复杂度为 O(1)。 - -稳定性: - -堆排序**不是稳定排序算法**。在堆排序中,可能会破坏相同元素的相对顺序,因此它不是稳定的排序算法。 - -堆排序由于其高效性和原地排序的特性,常用于需要稳定且较高性能的排序任务。虽然堆排序的实现相对复杂,但它的时间复杂度稳定在 O(n log n),在实践中具有较好的性能表现。 - -## 基数排序 - -基数排序(Radix Sort)是一种非比较性的排序算法,它根据关键字的每个位的值来排序。基数排序适用于元素都是整数的数组,其中每个元素都有相同的位数或范围。基本思想是将待排序的元素按照位数进行分组,然后按照每一位的顺序依次排序。 - -步骤: - -1. **按照最低有效位进行排序**:从最低位(个位)开始,将元素按照该位的值进行分组(例如 0 到 9),并按照顺序重新排列。 - -2. **依次对更高位进行排序**:对每一位重复上述排序过程,直到按照最高位排序完成。 - -3. **合并分组**:每次按照位数排序后,将所有分组合并为一个数组,形成新的待排序数组。 - -4. **重复步骤 1~3**,直到所有位都被处理完毕。 - -示例: - -假设我们有一个无序数组 `[170, 45, 75, 90, 802, 24, 2, 66]`,使用基数排序对其进行排序: - -1. **按照个位进行排序**: - 将数字按照个位的值进行分组:`[170, 90, 802, 2], [24], [45, 75], [66]`,并按照顺序重新排列:`[170, 90, 802, 2, 24, 45, 75, 66]`。 - -2. **按照十位进行排序**: - 将数字按照十位的值进行分组:`[802, 2], [24], [45, 66], [75], [170, 90]`,并按照顺序重新排列:`[802, 2, 24, 45, 66, 75, 170, 90]`。 - -3. **按照百位进行排序**(如果有的话,本例中没有)。 - -4. 排序完成,得到有序数组 `[2, 24, 45, 66, 75, 90, 170, 802]`。 - -代码实现: - -```js -// 获取数字的指定位数上的数字 -function getDigit(num, place) { - return Math.floor(Math.abs(num) / 10 ** place) % 10 -} - -// 获取数字的位数(最大位数) -function digitCount(num) { - if (num === 0) return 1 - return Math.floor(Math.log10(Math.abs(num))) + 1 -} - -// 获取数组中最大数字的位数 -function mostDigits(nums) { - let maxDigits = 0 - for (let i = 0; i < nums.length; i++) { - maxDigits = Math.max(maxDigits, digitCount(nums[i])) - } - return maxDigits -} - -function radixSort(nums) { - const maxDigitCount = mostDigits(nums) - - for (let k = 0; k < maxDigitCount; k++) { - // 创建 10 个桶(0 到 9) - const digitBuckets = Array.from({ length: 10 }, () => []) - - // 将数字放入相应的桶中 - for (let i = 0; i < nums.length; i++) { - const digit = getDigit(nums[i], k) - digitBuckets[digit].push(nums[i]) - } - - // 合并所有桶中的数字成为新的待排序数组 - nums = [].concat(...digitBuckets) - } - - return nums -} - -radixSort([6, 1, 5, 4, 2, 3]) // [1, 2, 3, 4, 5, 6] -``` - -时间复杂度: - -- **最优时间复杂度**:O(n * k) - 最优情况下,每个关键字的位数相同,基数排序的时间复杂度为 O(n * k),其中 n 是元素个数,k 是关键字的位数。 - -- **最坏时间复杂度**:O(n * k) - 最坏情况下,基数排序的时间复杂度仍然为 O(n * k)。 - -- **平均时间复杂度**:O(n * k) - 基数排序的平均时间复杂度也为 O(n * k),其中 k 通常为常数。 - -基数排序的时间复杂度主要取决于关键字的位数和元素个数,与元素的大小范围无关。 - -空间复杂度: - -基数排序的空间复杂度取决于辅助存储空间的使用,通常需要一个额外的数组来存储中间结果。因此,其空间复杂度为 O(n + k),其中 n 是元素个数,k 是关键字的范围(通常是 10)。 - -稳定性: - -基数排序是一种**稳定排序算法**。在基数排序过程中,相同位数的元素根据其原始顺序进行排序,不会改变相等元素的相对位置,因此是稳定的。 - -基数排序适用于处理整数或字符串等具有固定位数的元素集合。它的时间复杂度相对较低,并且是稳定排序算法,因此在一些特定的排序场景中具有一定的优势。 - -## 计数排序 - -计数排序(Counting Sort)是一种非比较性的排序算法,适用于待排序元素都属于一个有限范围的整数。计数排序的基本思想是通过统计待排序数组中每个元素出现的次数,然后根据统计信息将元素放置到正确的位置上。 - -步骤: - -1. **统计元素出现次数**:遍历待排序数组,统计每个元素出现的次数,存储在一个辅助数组中。 -2. **累加统计次数**:对统计数组进行累加,使得每个位置存储的值表示小于等于该值的元素的个数。 -3. **根据统计信息排序**:遍历待排序数组,根据统计数组中的信息,将元素放置到正确的位置上。 - -示例: - -假设我们有一个无序数组 `[4, 2, 2, 8, 3, 3, 1]`,使用计数排序对其进行排序: - -1. **统计元素出现次数**:统计数组中每个元素的出现次数:`[1:1, 2:2, 3:2, 4:1, 8:1]`。 - -2. **累加统计次数**:将统计数组中的值进行累加:`[1:1, 2:3, 3:5, 4:6, 8:7]`,表示小于等于每个元素的个数。 - -3. **根据统计信息排序**:根据累加统计次数,将待排序数组中的元素放置到正确的位置上,得到有序数组 `[1, 2, 2, 3, 3, 4, 8]`。 - -代码实现: - -```js -function countingSort(array) { - // 找到待排序数组中的最大值和最小值 - let min = array[0] - let max = array[0] - for (let i = 1; i < array.length; i++) { - if (array[i] < min) min = array[i] - if (array[i]> max) max = array[i] - } - - // 创建统计数组,长度为 max - min + 1 - const countArray = new Array(max - min + 1).fill(0) - - // 统计每个元素出现的次数 - for (let i = 0; i < array.length; i++) { - countArray[array[i] - min]++ - } - - // 根据统计信息对元素进行排序 - let sortedIndex = 0 - for (let i = 0; i < countArray.length; i++) { - while (countArray[i]> 0) { - array[sortedIndex] = i + min - sortedIndex++ - countArray[i]-- - } - } - - return array -} - -countingSort([6, 1, 5, 4, 2, 3]) // [1, 2, 3, 4, 5, 6] -``` - -时间复杂度: - -- **最优时间复杂度**:O(n + k) - 最优情况下,计数排序的时间复杂度为 O(n + k),其中 n 是元素个数,k 是元素的范围。 - -- **最坏时间复杂度**:O(n + k) - 最坏情况下,计数排序的时间复杂度仍然为 O(n + k)。 - -- **平均时间复杂度**:O(n + k) - 计数排序的平均时间复杂度也为 O(n + k)。 - -计数排序的时间复杂度主要取决于元素的范围,而与元素的个数无关。 - -空间复杂度: - -计数排序的空间复杂度取决于额外的计数数组和输出数组。因此,其空间复杂度为 O(n + k),其中 n 是元素个数,k 是元素的范围。 - -稳定性: - -计数排序是一种**稳定排序算法**。在计数排序中,相同元素的相对顺序不会改变,因此是稳定的。 - -计数排序适用于对一定范围内的整数进行排序,并且适合于元素范围不是很大的情况下。由于其时间复杂度和空间复杂度均为线性,因此在一些特定的排序场景中具有较好的性能表现。 \ No newline at end of file diff --git a/src/docs/data-structure/Array.md b/src/docs/data-structure/Array.md deleted file mode 100644 index 1614902..0000000 --- a/src/docs/data-structure/Array.md +++ /dev/null @@ -1,81 +0,0 @@ -# 数组 - -数组是最简单的内存数据结构,几乎所有的编程语言都原生支持数组类型。 - -大多数强类型的编程语言里面数组通常情况下都用于存储一系列同一种数据类型的值,但在 JavaScript 里,数组中可以保存不同类型的值。 - -## 创建和初始化数组 - -- 使用 `new Array()` 创建数组 - - ```js - const daysOfWeek = new Array( - "Sunday", - "Monday", - "Tuesday", - "Wednesday", - "Thursday", - "Friday", - "Saturday" - ); - // ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'] - ``` - -- 使用 `[]` 创建数组 - ```js - const daysOfWeek = [ - "Sunday", - "Monday", - "Tuesday", - "Wednesday", - "Thursday", - "Friday", - "Saturday", - ]; - // ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'] - ``` - -## 数组常见操作 - -### 添加元素 - -- 添加一个元素到数组的最后位置 `array.push(item)` -- 在数组首位插入一个元素 `array.unshift(item)` -- 在指定索引位置插入元素 `array.splice(index, 0, item)` -> splice() 第二个参数为 0 时,表示插入数据。 - ```js - const myArray = [1, 2, 3]; - // 在索引 0 的位置,插入 A - myArray.splice(0, 0, "A"); - console.log(myArray); //--> ['A', 1, 2, 3] - ``` - -### 删除元素 - -- 删除数组最后的元素 `array.pop()` -- 删除数组首位的元素 `array.shift()` -- 删除指定索引位置的元素 `array.splice(start, deleteCount)` - ```js - const myArray2 = [1, 2, 3, 4, 5]; - // 删除索引 3 位置起的 2 个元素 - myArray2.splice(3, 2); - console.log(myArray2); //--> [1, 2, 3] - ``` - -### 修改元素 - -- 修改指定索引位置的元素 `array.splice(index, 1, item)` - ```js - const myArray3 = [1, 2, 3, 4, 5, 6]; - // 修改索引 1 的位置的元素为 AA - myArray3.splice(1, 1, "AA"); - console.log(myArray3); //--> [1, "AA", 3, 4, 5, 6] - ``` - -- 修改指定索引位置的几个元素 `array.splice(index, number, item)` - ```js - const myArray4 = [1, 2, 3, 4, 5, 6, 7]; - // 在索引 2 的位置起,修改两个元素为 AA BB - myArray4.splice(2, 2, "AA", "BB"); - console.log(myArray4); //--> [1, 2, "AA", "BB", 5, 6, 7] - ``` diff --git a/src/docs/foreword.md b/src/docs/foreword.md deleted file mode 100644 index cd232aa..0000000 --- a/src/docs/foreword.md +++ /dev/null @@ -1,110 +0,0 @@ -# 前言 - -## 什么是数据结构 - -### 数据结构的定义 - -- "数据结构是数据对象,以及存在于该对象的实例和组成实例的数据元素之间的各种联系。这些联系可以通过定义相关的函数来给出。" --- 《数据结构、算法与应用》 -- "数据结构是 ADT(抽象数据类型 Abstract Data Type)的物理实现。" --- 《数据结构与算法分析》 -- "数据结构(data structure)是计算机中存储、组织数据的方式。通常情况下,精心选择的数据结构可以带来最优效率的算法。" ---中文维基百科 -- 从自己角度认识,数据结构就是在计算机中,存储和组织数据的方式。 - -### 数据结构在生活中应用 - -我们知道,计算机中数据量非常庞大,如何以高效的方式组织和存储呢? - -例如:一个庞大的图书馆中存放了大量的书籍,我们不仅仅要把书放进入,还应该在合适的时候能够取出来。 - -图书摆放要使得两个相关操作方便实现: - -- 操作 1:新书怎么插入? -- 操作 2:怎么找到某本指定的书? - -图书各种摆放方式: - -- 方法 1:随便放 - - - 操作 1:哪里有空位放哪里。 - - 操作 2:盲目找,大海捞针。 - -- 方法 2:按照书名的拼音字母顺序排放 - - - 操作 1:新进一本《阿 Q 正传》,按照字母顺序找到位置,插入。 - - 操作 2:二分查找法。 - -- 方法 3:把书架划分成几块区域,按照类别存放,类别中按照字母顺序。 - - - 操作 1:先定类别,二分查找确定位置,移出空位。 - - 操作 2:先定类别,再二分查找。 - -结论: - -- 解决问题方法的效率,根据数据的组织方式有关。 -- 计算机中存储的数据量相对于图书馆的书籍来说数据量更大,更多。 - -以什么样的方式来存储和组织我们的数据,才能在使用数据时更加方便呢?这就是数据结构需要考虑的问题。 - -### 常见的数据结构 - -- 数组(Array) -- 栈(Stack) -- 堆(Heap) -- 链表(Linked List) -- 图(Graph) -- 散列表(Hash) -- 队列(Queue) -- 树(Tree) - -数据结构与算法与语言无关,常见的编程语言都有**直接或间接**的使用上述常见的数据结构。 - -## 什么是算法 - -### 算法(Algorithm)的定义 - -- 一个有限指令集,每条指令的描述不依赖于语言。 -- 接收一些输入(有些情况下不需要输入)。 -- 产生输出。 -- 一定在有限步骤之后终止。 - -### 算法通俗理解 - -- Algorithm 这个单词本意就是解决问题的办法/步骤逻辑。 -- 数据结构的实现,离不开算法。 - -### 算法案例 - -假如上海和杭州之间有一条高架线,高架线长度是 1,000,000 米,有一天高架线中有其中一米出现了故障,请你想出一种算法,可以快速定位到处问题的地方。 - -- 线性查找 - - - 从上海的起点开始一米一米的排查,最终一定能找到出问题的线段。 - - 但是如果线段在另一头,我们需要排查 1,000,000 次,这是最坏的情况,平均需要 500,000 次。 - -- 二分查找 - - - 从中间位置开始排查,看一下问题出在上海到中间位置,还是中间到杭州的位置。 - - 查找对应的问题后,再从中间位置分开,重新锁定一般的路程。 - - 最坏的情况,需要多少次可以排查完呢?最坏的情况是 20 次就可以找到出问题的地方。 - - 怎么计算出来的呢?log(1000000, 2),以 2 位底,1000000 的对数 ≈ 20。 - -结论: -你会发现,解决问题的办法有很多,但是好的算法对比于差的算法,效率天壤之别。 - - -## 学习数据结构与算法的好处 - -- **解决问题的能力**:可以教会你如何系统地思考和解决复杂问题。例如:学会如何将一个大问题分解成更小、更可管理的问题,然后逐步解决这些问题。 - -- **掌握基础知识**:许多高级的编程概念和技术(如数据库系统、操作系统、编译器等)都基于基础的数据结构和算法知识,掌握这些基础知识,可以更容易理解和学习这些高级技术。 - -- **理解计算机科学的核心**:数据结构和算法是计算机科学的核心内容。通过学习它们,可以更深入地理解计算机的工作原理和计算理论。 - -- **提高编程能力**:可以帮助你编写更高效的代码。能够选择合适的数据结构和算法,可以显著提升程序的性能和效率。 - -- **编写可维护的代码**:选择合适的数据结构不仅能提高代码的效率,还能提高代码的可读性和可维护性。良好的数据结构设计能够使代码更清晰、更易于理解和修改。 - -- **提高代码效率**:优秀的算法和数据结构设计能够显著减少程序的运行时间和内存消耗,这在处理大数据或实时系统中尤为重要。 - -- **增强面试表现**:许多大公司的面试(如 Google、微软、字节跳动、腾讯等)都会考察应聘者对数据结构和算法的掌握情况。 - -- **支持技术进步**:在科研和开发前沿技术时,数据结构和算法的创新和优化是必不可少的。无论是人工智能、机器学习,还是大数据处理,都离不开高效的算法设计。 \ No newline at end of file diff --git a/src/docs/index.md b/src/docs/index.md deleted file mode 100644 index 33454af..0000000 --- a/src/docs/index.md +++ /dev/null @@ -1,20 +0,0 @@ ---- -# https://vitepress.dev/reference/default-theme-home-page -layout: home - -hero: - name: "JavaScript" - text: "数据结构与算法" - tagline: "从 0 到 1 开始学习 JavaScript 数据结构与算法" - actions: - - theme: brand - text: 开始学习 - link: /foreword - - theme: alt - text: 数据结构 - link: /data-structure/Array - - theme: alt - text: 算法 - link: /algorithm/sort ---- - diff --git a/src/docs/public/CNAME b/src/docs/public/CNAME deleted file mode 100644 index 01ed026..0000000 --- a/src/docs/public/CNAME +++ /dev/null @@ -1 +0,0 @@ -data-structure-and-algorithm.xpoet.cn diff --git a/src/docs/public/data-structure/BinarySearchTree/index.html b/src/docs/public/data-structure/BinarySearchTree/index.html deleted file mode 100644 index 9662727..0000000 --- a/src/docs/public/data-structure/BinarySearchTree/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - 二叉搜索树 - -
-

二叉搜索树的实现和测试

- - -

AltStyle によって変換されたページ (->オリジナル) /

- \ No newline at end of file diff --git a/src/docs/public/data-structure/DoublyLinkedList/index.html b/src/docs/public/data-structure/DoublyLinkedList/index.html deleted file mode 100644 index 524b9bf..0000000 --- a/src/docs/public/data-structure/DoublyLinkedList/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - 双向链表 - - -

双向链表的实现和测试

- - - - \ No newline at end of file diff --git a/src/docs/public/data-structure/HashTable/index.html b/src/docs/public/data-structure/HashTable/index.html deleted file mode 100644 index be7e578..0000000 --- a/src/docs/public/data-structure/HashTable/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - 哈希表 - - -

哈希表的实现和测试

- - - - \ No newline at end of file diff --git a/src/docs/public/data-structure/LinkedList/index.html b/src/docs/public/data-structure/LinkedList/index.html deleted file mode 100644 index e5589f5..0000000 --- a/src/docs/public/data-structure/LinkedList/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - 单向链表 - - -

单向链表的实现和测试

- - - - \ No newline at end of file diff --git a/src/docs/public/data-structure/Map/index.html b/src/docs/public/data-structure/Map/index.html deleted file mode 100644 index d98c8c7..0000000 --- a/src/docs/public/data-structure/Map/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - 字典 - - -

字典的实现和测试

- - - - \ No newline at end of file diff --git a/src/docs/public/data-structure/PriorityQueue/index.html b/src/docs/public/data-structure/PriorityQueue/index.html deleted file mode 100644 index 7d6d093..0000000 --- a/src/docs/public/data-structure/PriorityQueue/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - 优先队列 - - -

优先队列的实现和测试

- - - - \ No newline at end of file diff --git a/src/docs/public/data-structure/Queue/index.html b/src/docs/public/data-structure/Queue/index.html deleted file mode 100644 index b30088f..0000000 --- a/src/docs/public/data-structure/Queue/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - 队列 - - -

队列的实现和测试

- - - - \ No newline at end of file diff --git a/src/docs/public/data-structure/Set/index.html b/src/docs/public/data-structure/Set/index.html deleted file mode 100644 index a57928b..0000000 --- a/src/docs/public/data-structure/Set/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - 集合 - - -

集合的实现和测试

- - - - \ No newline at end of file diff --git a/src/docs/public/data-structure/Stack/index.html b/src/docs/public/data-structure/Stack/index.html deleted file mode 100644 index 281b505..0000000 --- a/src/docs/public/data-structure/Stack/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - 栈 - - -

栈的实现和测试

- - - - \ No newline at end of file diff --git a/src/docs/public/images/algorithm/img-01.png b/src/docs/public/images/algorithm/img-01.png deleted file mode 100644 index 800989a..0000000 Binary files a/src/docs/public/images/algorithm/img-01.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-01.png b/src/docs/public/images/data-structure/img-01.png deleted file mode 100644 index a5ed6c7..0000000 Binary files a/src/docs/public/images/data-structure/img-01.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-02.png b/src/docs/public/images/data-structure/img-02.png deleted file mode 100644 index d67ee7c..0000000 Binary files a/src/docs/public/images/data-structure/img-02.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-03.png b/src/docs/public/images/data-structure/img-03.png deleted file mode 100644 index 86b8258..0000000 Binary files a/src/docs/public/images/data-structure/img-03.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-04.png b/src/docs/public/images/data-structure/img-04.png deleted file mode 100644 index 5073fb6..0000000 Binary files a/src/docs/public/images/data-structure/img-04.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-05.png b/src/docs/public/images/data-structure/img-05.png deleted file mode 100644 index fca677b..0000000 Binary files a/src/docs/public/images/data-structure/img-05.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-06.png b/src/docs/public/images/data-structure/img-06.png deleted file mode 100644 index 6fc0223..0000000 Binary files a/src/docs/public/images/data-structure/img-06.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-07.png b/src/docs/public/images/data-structure/img-07.png deleted file mode 100644 index a183516..0000000 Binary files a/src/docs/public/images/data-structure/img-07.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-08.png b/src/docs/public/images/data-structure/img-08.png deleted file mode 100644 index b864a5a..0000000 Binary files a/src/docs/public/images/data-structure/img-08.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-09.png b/src/docs/public/images/data-structure/img-09.png deleted file mode 100644 index 99e34f4..0000000 Binary files a/src/docs/public/images/data-structure/img-09.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-10.png b/src/docs/public/images/data-structure/img-10.png deleted file mode 100644 index f6acec5..0000000 Binary files a/src/docs/public/images/data-structure/img-10.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-11.png b/src/docs/public/images/data-structure/img-11.png deleted file mode 100644 index 11349f5..0000000 Binary files a/src/docs/public/images/data-structure/img-11.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-12.png b/src/docs/public/images/data-structure/img-12.png deleted file mode 100644 index 1224658..0000000 Binary files a/src/docs/public/images/data-structure/img-12.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-13.png b/src/docs/public/images/data-structure/img-13.png deleted file mode 100644 index 283c8a5..0000000 Binary files a/src/docs/public/images/data-structure/img-13.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-14.png b/src/docs/public/images/data-structure/img-14.png deleted file mode 100644 index 1222361..0000000 Binary files a/src/docs/public/images/data-structure/img-14.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-15.png b/src/docs/public/images/data-structure/img-15.png deleted file mode 100644 index 1627de2..0000000 Binary files a/src/docs/public/images/data-structure/img-15.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-16.png b/src/docs/public/images/data-structure/img-16.png deleted file mode 100644 index 2339e30..0000000 Binary files a/src/docs/public/images/data-structure/img-16.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-17.png b/src/docs/public/images/data-structure/img-17.png deleted file mode 100644 index 16d49e4..0000000 Binary files a/src/docs/public/images/data-structure/img-17.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-18.png b/src/docs/public/images/data-structure/img-18.png deleted file mode 100644 index 8cf3dc8..0000000 Binary files a/src/docs/public/images/data-structure/img-18.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-19.png b/src/docs/public/images/data-structure/img-19.png deleted file mode 100644 index 55ef7f3..0000000 Binary files a/src/docs/public/images/data-structure/img-19.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-20.png b/src/docs/public/images/data-structure/img-20.png deleted file mode 100644 index aa502a7..0000000 Binary files a/src/docs/public/images/data-structure/img-20.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-21.png b/src/docs/public/images/data-structure/img-21.png deleted file mode 100644 index 21223f0..0000000 Binary files a/src/docs/public/images/data-structure/img-21.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-22.png b/src/docs/public/images/data-structure/img-22.png deleted file mode 100644 index 698070f..0000000 Binary files a/src/docs/public/images/data-structure/img-22.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-23.png b/src/docs/public/images/data-structure/img-23.png deleted file mode 100644 index 534e8c1..0000000 Binary files a/src/docs/public/images/data-structure/img-23.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-24.png b/src/docs/public/images/data-structure/img-24.png deleted file mode 100644 index f4abbef..0000000 Binary files a/src/docs/public/images/data-structure/img-24.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-25.png b/src/docs/public/images/data-structure/img-25.png deleted file mode 100644 index 522867d..0000000 Binary files a/src/docs/public/images/data-structure/img-25.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-26.png b/src/docs/public/images/data-structure/img-26.png deleted file mode 100644 index 653f440..0000000 Binary files a/src/docs/public/images/data-structure/img-26.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-27.png b/src/docs/public/images/data-structure/img-27.png deleted file mode 100644 index fe243de..0000000 Binary files a/src/docs/public/images/data-structure/img-27.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-28.png b/src/docs/public/images/data-structure/img-28.png deleted file mode 100644 index 9ccb22b..0000000 Binary files a/src/docs/public/images/data-structure/img-28.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-29.png b/src/docs/public/images/data-structure/img-29.png deleted file mode 100644 index cdb3e23..0000000 Binary files a/src/docs/public/images/data-structure/img-29.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-30.png b/src/docs/public/images/data-structure/img-30.png deleted file mode 100644 index c54f032..0000000 Binary files a/src/docs/public/images/data-structure/img-30.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-31.png b/src/docs/public/images/data-structure/img-31.png deleted file mode 100644 index 508ff83..0000000 Binary files a/src/docs/public/images/data-structure/img-31.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-32.png b/src/docs/public/images/data-structure/img-32.png deleted file mode 100644 index 90fb9b6..0000000 Binary files a/src/docs/public/images/data-structure/img-32.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-33.png b/src/docs/public/images/data-structure/img-33.png deleted file mode 100644 index 5615122..0000000 Binary files a/src/docs/public/images/data-structure/img-33.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-34.png b/src/docs/public/images/data-structure/img-34.png deleted file mode 100644 index ce95c86..0000000 Binary files a/src/docs/public/images/data-structure/img-34.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-35.png b/src/docs/public/images/data-structure/img-35.png deleted file mode 100644 index 4e7e6ff..0000000 Binary files a/src/docs/public/images/data-structure/img-35.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-36.png b/src/docs/public/images/data-structure/img-36.png deleted file mode 100644 index 5c693d2..0000000 Binary files a/src/docs/public/images/data-structure/img-36.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-37.png b/src/docs/public/images/data-structure/img-37.png deleted file mode 100644 index d285c18..0000000 Binary files a/src/docs/public/images/data-structure/img-37.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-38.png b/src/docs/public/images/data-structure/img-38.png deleted file mode 100644 index 4472808..0000000 Binary files a/src/docs/public/images/data-structure/img-38.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-39.png b/src/docs/public/images/data-structure/img-39.png deleted file mode 100644 index 5192525..0000000 Binary files a/src/docs/public/images/data-structure/img-39.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-40.png b/src/docs/public/images/data-structure/img-40.png deleted file mode 100644 index 5b96daf..0000000 Binary files a/src/docs/public/images/data-structure/img-40.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-41.png b/src/docs/public/images/data-structure/img-41.png deleted file mode 100644 index 77995b5..0000000 Binary files a/src/docs/public/images/data-structure/img-41.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-42.png b/src/docs/public/images/data-structure/img-42.png deleted file mode 100644 index cb719fe..0000000 Binary files a/src/docs/public/images/data-structure/img-42.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-43.png b/src/docs/public/images/data-structure/img-43.png deleted file mode 100644 index bd406cc..0000000 Binary files a/src/docs/public/images/data-structure/img-43.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-44.png b/src/docs/public/images/data-structure/img-44.png deleted file mode 100644 index c61b944..0000000 Binary files a/src/docs/public/images/data-structure/img-44.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-45.png b/src/docs/public/images/data-structure/img-45.png deleted file mode 100644 index 355a099..0000000 Binary files a/src/docs/public/images/data-structure/img-45.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-46.png b/src/docs/public/images/data-structure/img-46.png deleted file mode 100644 index ca3219a..0000000 Binary files a/src/docs/public/images/data-structure/img-46.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-47.png b/src/docs/public/images/data-structure/img-47.png deleted file mode 100644 index 9c62eb5..0000000 Binary files a/src/docs/public/images/data-structure/img-47.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-48.png b/src/docs/public/images/data-structure/img-48.png deleted file mode 100644 index 9a1def4..0000000 Binary files a/src/docs/public/images/data-structure/img-48.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-49.png b/src/docs/public/images/data-structure/img-49.png deleted file mode 100644 index 1112449..0000000 Binary files a/src/docs/public/images/data-structure/img-49.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-50.png b/src/docs/public/images/data-structure/img-50.png deleted file mode 100644 index 0be338c..0000000 Binary files a/src/docs/public/images/data-structure/img-50.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-51.png b/src/docs/public/images/data-structure/img-51.png deleted file mode 100644 index 0be338c..0000000 Binary files a/src/docs/public/images/data-structure/img-51.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-52.png b/src/docs/public/images/data-structure/img-52.png deleted file mode 100644 index c5f1215..0000000 Binary files a/src/docs/public/images/data-structure/img-52.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-53.png b/src/docs/public/images/data-structure/img-53.png deleted file mode 100644 index 5008624..0000000 Binary files a/src/docs/public/images/data-structure/img-53.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-54.png b/src/docs/public/images/data-structure/img-54.png deleted file mode 100644 index 08e302e..0000000 Binary files a/src/docs/public/images/data-structure/img-54.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-55.png b/src/docs/public/images/data-structure/img-55.png deleted file mode 100644 index fe1d7bf..0000000 Binary files a/src/docs/public/images/data-structure/img-55.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-56.png b/src/docs/public/images/data-structure/img-56.png deleted file mode 100644 index d7dfdb6..0000000 Binary files a/src/docs/public/images/data-structure/img-56.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-57.png b/src/docs/public/images/data-structure/img-57.png deleted file mode 100644 index 155b509..0000000 Binary files a/src/docs/public/images/data-structure/img-57.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-58.png b/src/docs/public/images/data-structure/img-58.png deleted file mode 100644 index defa84e..0000000 Binary files a/src/docs/public/images/data-structure/img-58.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-59.png b/src/docs/public/images/data-structure/img-59.png deleted file mode 100644 index fdaadd9..0000000 Binary files a/src/docs/public/images/data-structure/img-59.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-60.png b/src/docs/public/images/data-structure/img-60.png deleted file mode 100644 index 10f4566..0000000 Binary files a/src/docs/public/images/data-structure/img-60.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-61.png b/src/docs/public/images/data-structure/img-61.png deleted file mode 100644 index b301bf1..0000000 Binary files a/src/docs/public/images/data-structure/img-61.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-62.png b/src/docs/public/images/data-structure/img-62.png deleted file mode 100644 index 68526b3..0000000 Binary files a/src/docs/public/images/data-structure/img-62.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-63.png b/src/docs/public/images/data-structure/img-63.png deleted file mode 100644 index 54ecd6f..0000000 Binary files a/src/docs/public/images/data-structure/img-63.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-64.png b/src/docs/public/images/data-structure/img-64.png deleted file mode 100644 index e1ccb07..0000000 Binary files a/src/docs/public/images/data-structure/img-64.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-65.png b/src/docs/public/images/data-structure/img-65.png deleted file mode 100644 index b9f9329..0000000 Binary files a/src/docs/public/images/data-structure/img-65.png and /dev/null differ diff --git a/src/docs/public/images/data-structure/img-66.png b/src/docs/public/images/data-structure/img-66.png deleted file mode 100644 index 982dee5..0000000 Binary files a/src/docs/public/images/data-structure/img-66.png and /dev/null differ diff --git a/src/docs/public/images/logo.png b/src/docs/public/images/logo.png deleted file mode 100644 index 7b5ffab..0000000 Binary files a/src/docs/public/images/logo.png and /dev/null differ diff --git a/src/index.html b/src/index.html new file mode 100644 index 0000000..52c2934 --- /dev/null +++ b/src/index.html @@ -0,0 +1,12 @@ + + + + + JavaScript 数据结构与算法 + + + +

JavaScript 数据结构与算法

+ + + diff --git a/src/index.js b/src/index.js new file mode 100644 index 0000000..6501cf7 --- /dev/null +++ b/src/index.js @@ -0,0 +1,30 @@ +// 导入栈结构的封装及测试代码 +// import './Stack' + +// 导入队列结构的封装及测试代码 +// import './Queue' + +// 导入优先队列结构的封装及测试代码 +// import './PriorityQueue' + +// 导入单向链表结构的封装及测试代码 +// import './LinkedList' + +// 导入双向链表结构的封装及测试代码 +import './DoublyLinkedList' + +// 导入集合结构的封装及测试代码 +// import './Set' + +// 导入字典结构的封装及测试代码 +// import './Map' + +// 导入哈希表结构的封装及测试代码 +// import './HashTable'; + +// 导入树结构的封装及测试代码 +// import './Tree'; + + +// // 导入图结构的封装及测试代码 +// import './Graph'; \ No newline at end of file diff --git a/webpack.config.js b/webpack.config.js new file mode 100644 index 0000000..5b7f487 --- /dev/null +++ b/webpack.config.js @@ -0,0 +1,54 @@ +const path = require('path'); +const htmlWebpackPlugin = require('html-webpack-plugin'); + +module.exports = { + // 配置入口 + entry: './src/index.js', + + // 配置出口 + output: { + path: path.resolve(__dirname, 'dist'), + filename: 'main.js' + }, + + // 配置加载器 + module: { + rules: [ + { + test: /\.css$/, // 匹配 css 文件 + use: ['style-loader', 'css-loader'] + }, + { + test: /\.js?$/, // 匹配 js 或 jsx 文件 + exclude: /node_modules/, // 排除 node_modules 文件夹 + use: { + loader: 'babel-loader', + options: { + // babel 转义的配置选项 + babelrc: false, + presets: [ + [require.resolve('@babel/preset-env'), {modules: false}] + ], + cacheDirectory: true + } + } + } + ] + }, + + // 配置插件 + plugins: [ + new htmlWebpackPlugin({ + template: 'src/index.html', + filename: 'index.html', + inject: true + }) + ], + + // 本地开发服务 + devServer: { + contentBase: './dist', + host: 'localhost', + port: 8888 + } +}