# 算法
// 定义待排序的数组
const arr = [1, 23, 42, 1, 323, 43, 2, 3, 3, 52]
1
2
2
# 冒泡算法
console.log(bubbleSort(arr)) // [1, 2, 3, 23, 42, 43, 52, 323]
function bubbleSort(arr){
for(let i = 0; i < arr.length - 1; i++){
for(let j = 0; j < arr.length - 1 - i; j++){
if(arr[j] > arr[j + 1]){
let temp = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = temp
}
}
}
return arr
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
# 快速排序算法
console.log(quickSort(arr)) // [1, 2, 3, 23, 42, 43, 52, 323]
function quickSort(arr){
if(arr.length <= 1){
return arr
}
let flag = arr[0]
let left = []
let right = []
for(let i = 1; i < arr.length; i++){
arr[i] > flag ? right.push(arr[i]) : left.push(arr[i])
}
return quickSort(left).concat(flag).concat(quickSort(right))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
# 递归
常见递归:
- 暴力递归
- 备忘录递归
- 非递归的动态规划解法
# 暴力递归
// 暴力递归
function fibViolence(n){
if(n == 1 || n == 2){
return 1
}
return vFib(n - 1) + vFib(n - 2)
}
console.log(fibViolence(40))
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
# 备忘录递归
// 备忘录递归
function fibCache(n){
let store = []
return Cache(store, n)
}
function Cache(store, n){
if(n == 1 || n == 2){
return 1
}
if(store[n]) return store[n]
store[n] = Cache(store, n - 1) + Cache(store, n - 2)
return store[n]
}
console.log(fibCache(100))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
支持微信、支付宝、QQ
赏
打赏请随意
您的支持，我的动力