├── README.md
├── stairs.js
├── flat.js
├── bubke.js
├── fib.js
├── change1.js
├── hash.js
├── stack.js
├── tree.html
├── change.js
├── quick.html
└── quick.js


/README.md:
--------------------------------------------------------------------------------
1 | # algorithm-lesson
2 | 算法演示代码
3 | 


--------------------------------------------------------------------------------
/stairs.js:
--------------------------------------------------------------------------------
1 | // 10个楼梯
2 | // 你一次可以爬一个，也可以爬两个
3 | 
4 | // 第10级，又两个方式到达
5 | //   1. 8级爬俩
6 | //   2  9级 爬一个


--------------------------------------------------------------------------------
/flat.js:
--------------------------------------------------------------------------------
 1 | // 数组打平
 2 | 
 3 | 
 4 | let arr = [1,2,3,[4,5,[6,7]],[8,9]]
 5 | Array.prototype.flat = function(){
 6 |   let arr = []
 7 |   this.forEach((item)=>{
 8 |     if(Array.isArray(item)){
 9 |       arr=arr.concat(item.flat())
10 |     }else{
11 |       arr.push(item)
12 |     }
13 |   })
14 |   return arr
15 | }
16 | console.log(arr.flat())
17 | 


--------------------------------------------------------------------------------
/bubke.js:
--------------------------------------------------------------------------------
 1 | let arr = [11,4,3,2,1,9,6,0]
 2 | // 冒泡
 3 | function bubleSort(arr){
 4 |   const len = arr.length
 5 |   for(let o=len;o>=2;o--){
 6 |     // 主要是遍历次数
 7 |     for(let i=0;i<=o-1;i++){
 8 |       if(arr[i]>arr[i+1]){
 9 |         [ arr[i], arr[i+1] ]=  [ arr[i+1], arr[i] ]
10 |       }
11 |     }
12 |   }
13 |   return arr
14 | }
15 | 
16 | console.log(bubleSort(arr))
17 | // 冒泡排序稳定


--------------------------------------------------------------------------------
/fib.js:
--------------------------------------------------------------------------------
 1 | // [1,1,2,3,5,8,13]
 2 | // 第一个版本 暴力递归
 3 | function fib(n){
 4 |   if(n==1 || n==2){
 5 |     return 1
 6 |   }
 7 |   return fib(n-1) + fib(n-2)
 8 | }
 9 | 
10 | // 中间存储 缓存版递归
11 | 
12 | function fib1(n){
13 |   let cache = []
14 |   return helper(cache,n)
15 | }
16 | function helper(cache,n){
17 |   if(n==1 || n==2){
18 |     return 1
19 |   }
20 |   if(cache[n]) return cache[n]
21 |   cache[n] = helper(cache,n-1) + helper(cache,n-2)
22 |   return cache[n]
23 | }
24 | 
25 | // 自底向上
26 | function fib2(n){
27 |   let dp  = []
28 |   dp[1] = dp[2] = 1
29 |   for(let i=3;i<=n;i++){
30 |     dp[i] = dp[i-1]+dp[i-2]
31 |   }
32 |   return dp[n]
33 | }
34 | 
35 | console.time('fib')
36 | console.log(fib2(145))
37 | console.timeEnd('fib')
38 | // 最简单的dp
39 | 


--------------------------------------------------------------------------------
/change1.js:
--------------------------------------------------------------------------------
 1 | 
 2 | // 贪心
 3 | class Change {
 4 |   constructor(changeType){
 5 |       this.changeType = changeType.sort((r1, r2) => r2 - r1)
 6 | 
 7 |   }
 8 |   makeChange(amount) {
 9 |       const arr = []
10 |       for (let i = 0; i < this.changeType.length; i++) {
11 |         while (amount - this.changeType[i] >= 0) {
12 |           arr.push(this.changeType[i])
13 |           amount = amount - this.changeType[i]
14 |         }
15 |       }
16 |       return arr
17 |     }
18 | }
19 | 
20 | const change = new Change([1, 5, 10, 20,50,100])
21 | 
22 | console.log(change.makeChange(36)) 
23 | console.log(change.makeChange(136)) 
24 | 
25 | console.log('-'.repeat(100))
26 | const change1 = new Change([1, 3, 4])
27 | 
28 | console.log(change1.makeChange(6)) // 其实33最好


--------------------------------------------------------------------------------
/hash.js:
--------------------------------------------------------------------------------
 1 | class HashTable{
 2 |   constructor(){
 3 |     this.items = []
 4 |   }
 5 |   get(key){
 6 |     const hash = this.keyToHash(key)
 7 |     return this.items[hash]    
 8 |   }
 9 |   set(key,value){
10 |     const hash = this.keyToHash(key)
11 |     this.items[hash] = value
12 |   }
13 |   remove(key){
14 |     const hash = this.keyToHash(key)
15 |     delete this.items[hash] 
16 |   }
17 |   keyToHash(key){
18 |     // 把字符串key，变成数字
19 |     let hash = 0
20 |     for(let i=0;i<key.length;i++){
21 |       hash += key.charCodeAt(i)
22 |     }
23 |     hash = hash%37 // 这个数字要随时变
24 |     // 数字会在37以内
25 |     return hash
26 |   }
27 |   log(){
28 |     console.log(this.items)
29 |   }
30 | }
31 | 
32 | let kkb = new HashTable()
33 | kkb.set('name','kaikeba')
34 | kkb.set('bestTeacher','大圣老师')
35 | console.log(kkb.get('name'))
36 | console.log(kkb.get('bestTeacher'))
37 | // kkb.remove('name')
38 | console.log(kkb.get('name'))
39 | kkb.log()
40 | 
41 | // 不同的key 算出的hash一样
42 | 
43 | 
44 | 
45 | 


--------------------------------------------------------------------------------
/stack.js:
--------------------------------------------------------------------------------
 1 | class Stack{
 2 | 
 3 |   constructor(){
 4 |     this.items = []
 5 |   }
 6 |   push(item){
 7 |     this.items.push(item)
 8 |   }
 9 |   pop(){
10 |     return this.items.pop()
11 |   }
12 | }
13 | // function(){
14 | //   ()=>{
15 | //     {}
16 | //   }
17 | 
18 | // 匹配括号语法
19 | 
20 | // [1,2,3]
21 | 
22 | // ({(())({})}) 匹配的
23 | // ({(()){})}) 不匹配了
24 | // 判定给的符号，是不是括号匹配正确
25 | 
26 | // ({(())({})})
27 | // [(,{,(,] (,
28 | function isBlance(symbol){
29 |   const stack = new Stack()
30 |   const left = '({'
31 |   const right =')}'
32 | 
33 |   let popValue
34 |   let blance = true
35 | 
36 |   for(let i=0;i<symbol.length;i++){
37 |     let s = symbol[i]
38 |     if(left.includes(s)){
39 |       stack.push(s)
40 |     }else if(right.includes(s)){
41 |       let popValue = stack.pop()
42 |       match(popValue, s)
43 |     }
44 |   }
45 |   function match(popValue, current){
46 |     if(left.indexOf(popValue) !==right.indexOf(current)){
47 |       // 不匹配了
48 |       blance = false
49 |     }
50 |   }
51 |   return blance
52 | }
53 | 
54 | console.log(isBlance("(({{}}))"))
55 | console.log(isBlance("(({{}()}))"))
56 | console.log(isBlance("(({{}))"))
57 | console.log(isBlance("(()=>{return ()=>{}})}"))
58 | 
59 | // html规范校验  （jsx解析）
60 | // 表达式计算


--------------------------------------------------------------------------------
/tree.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="UTF-8">
 5 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |   <meta http-equiv="X-UA-Compatible" content="ie=edge">
 7 |   <title>Document</title>
 8 | </head>
 9 | <!-- 树的遍历 -->
10 | <body>
11 |   <div id="app">
12 |     <div>哈喽</div>
13 |     <p>开课吧</p>
14 |     <div>
15 |       <span>123</span>
16 |       <button>xx</button>
17 |     </div>
18 |     <ul>
19 |       <li>123</li>
20 |     </ul>
21 |   </div>
22 |   <script>
23 |     function walk(node,func=()=>{}){
24 |       if(node instanceof window.Node){
25 |         _walk(node, func)
26 |       }
27 |       return node
28 |     }
29 |     function _walk(node, func){
30 |         func(node)
31 |         // 需要递归的
32 |         // 获取第一个子元素
33 |         node = node.firstChild
34 |         // 只要子元素存在
35 |         while(node){
36 |           // 对这个子元素 递归遍历
37 |           _walk(node,func)
38 |           // 遍历结束，开始遍历他的兄弟节点
39 |           node = node.nextSibling
40 |         }
41 |     }
42 | 
43 | 
44 |     walk(document.getElementById('app'), node=>{
45 |       console.log(node)
46 |     })
47 | 
48 | 
49 |     // {
50 |     //   type:"div",
51 |     //   props:{
52 |     //     children:[]
53 |     //   }
54 |     // }
55 | 
56 |     // 根据props.children来遍历
57 |   </script>
58 | </body>
59 | </html>


--------------------------------------------------------------------------------
/change.js:
--------------------------------------------------------------------------------
 1 | // 找零
 2 | 
 3 | // 我们的零钱 1 5 10 20 50 100
 4 | // 怎么找钱最合适
 5 | 
 6 | class Change{
 7 |   constructor(changeType){
 8 |     this.changeType = changeType
 9 |     this.cache = {}
10 |   }
11 |   makeChange(amount){
12 |     // 最少张数的一个数组
13 |     let min = []
14 |     if(!amount){
15 |       return []
16 |     }
17 |     if(this.cache[amount]){
18 |       return this.cache[amount]
19 |     }
20 |     for(let i=0;i<this.changeType.length;i++){
21 |       // 先找一张试试
22 |       const leftAmount = amount - this.changeType[i]
23 |       let newMin 
24 |       if(leftAmount>=0){
25 |         // 只要还得继续找钱
26 |         // 下一步找钱的数组
27 |         newMin = this.makeChange(leftAmount)
28 |       }
29 |       if(leftAmount>=0 && (newMin.length<min.length-1|| !min.length)){
30 |         // 纠正结果
31 |         min = [this.changeType[i]].concat(newMin)
32 |       }
33 |     }
34 |     return this.cache[amount] = min
35 |   }
36 | }
37 | 
38 | // const change = new Change([1,5,10,20,50,100])
39 | // console.log(change.makeChange(2))
40 | // console.log(change.makeChange(5))
41 | // console.log(change.makeChange(13))
42 | // console.log(change.makeChange(16))
43 | // console.log(change.makeChange(35))
44 | // console.log(change.makeChange(383))
45 | // 结论是慢慢优化出来的
46 | const change = new Change([1, 3, 4])
47 | 
48 | 
49 | console.log(change.makeChange(6)) // 其实33最好w
50 | 
51 | // 贪心给出的是411


--------------------------------------------------------------------------------
/quick.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="UTF-8">
 5 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |   <meta http-equiv="X-UA-Compatible" content="ie=edge">
 7 |   <title>Document</title>
 8 | </head>
 9 | <body>
10 |   
11 |   <script>
12 |     
13 |     // 先来一版好懂的 但是空间复杂度差一些
14 | let arr = [8,11,4,3,2,1,9,6,0]
15 | 
16 | // console.log(quickSort(arr))
17 | // 原地快排
18 | function quickSort1(arr, low=0,high=arr.length-1){
19 |   //   
20 | //   
21 | //   |              |
22 | // 6  0 ,4,3,2,1,8,9,11
23 | //              | |
24 |   if(low>=high){
25 |     return 
26 |   }
27 |   let left = low
28 |   let right = high
29 |   let flag = arr[left]
30 |   while(left<right){
31 |     // 从右边尝试找比flag小的, 比flag大，right坐移
32 |     if(left<right && flag<=arr[right]){
33 |       right --
34 |     }
35 |     arr[left] = arr[right]
36 | 
37 |     if(left<right && flag>=arr[left]){
38 |       left ++
39 |     }
40 |     arr[right] = arr[left]
41 |   }
42 |   arr[left] = flag
43 |   // quickSort1(arr,low,left-1)
44 |   // quickSort1(arr,left+1,high)
45 |   return arr
46 |  
47 | } 
48 | console.log([8,11,4,3,2,1,9,6,0])
49 | console.log(quickSort1(arr))
50 | 
51 | 
52 | // 为啥要取第一个
53 | // 其实随机的 只是为了发方便
54 | // 快速排序的复杂度是多少 (时间)
55 | // n*log n
56 | // 快速排序啥时候复杂度最差，如果一个数字已经排好序的
57 | // 复杂度是O(n^2) 取第1个的不好
58 | // 1. 随机取索引
59 | // 2. 快排之前，先做一下乱序
60 | 
61 | // [3,2,4,6,2,1]
62 | // [4,2,3,6,2,1]
63 |     </script>
64 | </body>
65 | </html>


--------------------------------------------------------------------------------
/quick.js:
--------------------------------------------------------------------------------
 1 | // 先来一版好懂的 但是空间复杂度差一些
 2 | let arr = [8,11,4,3,2,1,9,6,0]
 3 | function quickSort(arr){
 4 |   // 终止条件
 5 |   if(arr.length<=1){
 6 |     return arr
 7 |   }
 8 |   let left = []
 9 |   let right = []
10 |   let flag = arr.shift()
11 |   for(let i=0;i<arr.length;i++){
12 |     if(arr[i]<flag){
13 |       left.push(arr[i])
14 |     }else{
15 |       right.push(arr[i])
16 |     }
17 |   }
18 |   return quickSort(left).concat(flag, quickSort(right))
19 | 
20 | }
21 | 
22 | 
23 | // console.log(quickSort(arr))
24 | // 原地快排
25 | function quickSort1(arr, low=0,high=arr.length-1){
26 |   //   
27 | //   
28 | //   |              |
29 | // 6  0 ,4,3,2,1,8,9,11
30 | //              | |
31 |   if(low>=high){
32 |     return 
33 |   }
34 |   let left = low
35 |   let right = high
36 |   let flag = arr[left]
37 |   while(left<right){
38 |     // 从右边尝试找比flag小的, 比flag大，right坐移
39 |     if(left<right && flag<=arr[right]){
40 |       right --
41 |     }
42 |     arr[left] = arr[right]
43 | 
44 |     if(left<right && flag>=arr[left]){
45 |       left ++
46 |     }
47 |     arr[right] = arr[left]
48 |   }
49 |   arr[left] = flag
50 |   // quickSort1(arr,low,left-1)
51 |   // quickSort1(arr,left+1,high)
52 |   return arr
53 |  
54 | } 
55 | console.log([8,11,4,3,2,1,9,6,0])
56 | console.log(quickSort1(arr))
57 | 
58 | 
59 | // 为啥要取第一个
60 | // 其实随机的 只是为了发方便
61 | // 快速排序的复杂度是多少 (时间)
62 | // n*log n
63 | // 快速排序啥时候复杂度最差，如果一个数字已经排好序的
64 | // 复杂度是O(n^2) 取第1个的不好
65 | // 1. 随机取索引
66 | // 2. 快排之前，先做一下乱序
67 | 
68 | // [3,2,4,6,2,1]
69 | // [4,2,3,6,2,1]


--------------------------------------------------------------------------------