# 洗牌算法
对52张牌洗牌，要求尽量洗乱，而且原牌不能在原位置上重复
function arrayShuffle(arr) {
arr = [...arr];
function random(min, max) {
return Math.floor(Math.random() * (max - min + 1) + min);
}
for(let i = 0, len = arr.length; i < len - 1; i ++) {
let randomIndex = random(i + 1, len - 1);
[arr[i], arr[randomIndex]] = [arr[randomIndex], arr[i]]
}
return arr;
}
var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
arrayShuffle(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
# 设计一个数据结构
现在有n个微信群，每个群里面有2到m个人，设计一个数据结构存储这些信息，要求该结构能快速找出每一个人所在的所有的群Id。
# 找出重复数字
数组a[N]，存放了数字1至N-1，其中某个数字重复一次。写一个函数，找出被重复的数字。时间复杂度必须为O(N), 空间复杂度不能是O[N]。
function find(arr) {
let sum = arr.reduce((prev, curr) => prev + curr);
// sum 1 ~ N-1
let n = arr.length;
let sum2 = (1 + n - 1) * (n - 1) / 2;
return sum - sum2;
}
find([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10]); // 10
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
# 对称数字判断
现在有一个微信群，里面有n个人，每个人的id用整数int标示，现在要求找出id是对称数字的人出来，如3， 121， 12321。 请实现改查找函数，不能把整数转为字符串来判断。
let isMirror = function(num) {
let origin = num;
let sum = 0;
while(num !== 0) {
sum = sum * 10 + num % 10;
num = Math.floor(num / 10);
}
return sum === origin;
}
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# atoi
给定一个字符串，如“1234”，请实现一个函数，把这个字符串转成10进制整型，不能用系统函数
function atoi(str) {
let sum = 0;
for(let i = 0; i < str.length; i++) {
let data = +str[i];
sum = sum * 10 + data;
}
return sum;
}
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
# 二叉树路径节点之和
有一个二叉树，每个节点的值是一个整数。写一个函数，判断这棵树中是否存在从根到叶子节点的一个路径，这个路径上所有节点之和为某一个值。存在返回1， 否则返回0。
struct TreeNode
{
int value;
struct TreeNode *left, *right;
};
int haspath(struct TreeNode *root, int value)
1
2
3
4
5
6
2
3
4
5
6
function hasPath(root, target) {
if(root.left !== null && hasPath(root.left, target - root.value)) {
return 1;
} else if(root.right !== null && hasPath(root.right, target - root.value)) {
return 1;
} else if (root.left === null && root.right === null && root.value === target) {
return 1;
}
return 0;
}
var root = {
"value": 1,
"left": {
"value": 2,
"left": {
"value": 4,
"left": null,
"right": null
},
"right": {
"value": 5,
"left": null,
"right": null
}
},
"right": {
"value": 3,
"left": {
"value": 6,
"left": null,
"right": null
},
"right": {
"value": 7,
"left": null,
"right": null
}
}
};
hasPath(root, 7); // 1
hasPath(root, 8); // 1
hasPath(root, 10); // 1
hasPath(root, 11); // 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44