前端面试中的常见的算法难题
2016/10/27 · JavaScript
· 7 评论 ·
算法
初稿出处： Jack
Pu
虽说大家多数时候前端相当少有机缘接触到算法。非常多都交互性的操作，不过从各大公司面试来看，算法如故是考察的一方面。实际上学习数据结构与算法对于技术员去精通和剖判难题都是有赞助的。如若今后当我们面临较为复杂的主题素材，那个基础知识的储存能够扶助大家越来越好的优化解决思路。下边罗列在前面多个面试中平常碰着的多少个难点吧。
Q1 判定多个单词是或不是是回文？
虽说大家许多时候前端相当少有时机接触到算法。多数都交互性的操作，不过从各大集团面试来看，算法依然是调查的一端。实际上学习数据结构与算法对于技术员去驾驭和解析难题都以有协理的。假使以后当我们面临较为复杂的难题，这一个基础知识的积攒能够帮助大家更加好的优消除决思路。上边罗列在前面五个面试中时时遇上的多少个难点吧。
Q1 剖断几个单词是或不是是回文？
虽说小编们广大时候前端非常少有时机接触到算法。
Q1 判别多少个单词是还是不是是回文？
回文是指把同样的词汇或句子，在下文中调换个地点置或颠倒过来，发生首尾回环的情趣，叫做回文，也叫回环。比如mamam redivider .
过三个人得到那样的标题特别轻松想到用for
将字符串颠倒字母顺序然后极度就行了。其实根本的体察的正是对此reverse的落到实处。其实我们得以采取现有的函数，将字符串调换来数组，那些思路相当重要，大家得以具有越多的自由度去举办字符串的一对操作。
JavaScript
function checkPalindrom(str) { return str ==
str.split('').reverse().join(''); }
|
1
2
3
|
function checkPalindrom(str) {
return str == str.split('').reverse().join('');
}
|
回文是指把一样的词汇或句子，在下文中沟通地点或颠倒过来，产生首尾回环的情趣，叫做回文，也叫回环。比如mamam redivider .
Q1 判别一个单词是还是不是是回文？
回文是指把同样的词汇或句子，在下文中互交换一下地方置或颠倒过来，发生首尾回环的意趣，叫做回文，也叫回环。比如mamam redivider .
Q2 去掉一组整型数组重复的值
诸如输入: [1,13,24,11,11,14,1,2] 输出: [1,13,24,11,14,2]
需求去掉重复的11 和 1 这多少个因素。
|
1
2
3
|
比如输入: [1,13,24,11,11,14,1,2]
输出: [1,13,24,11,14,2]
需要去掉重复的11 和 1 这两个元素。
|
那道难题应际而生在比相当多的前端面试题中，主要调查个人对Object的利用，利用key来举办筛选。
JavaScript
/** * unique an array **/ let unique = function(arr) { let
hashTable = {}; let data = []; for(let i=0,l=arr.length;i<l;i++) {
if(!hashTable[arr[i]]) { hashTable[arr[i]] = true;
data.push(arr[i]); } } return data } module.exports = unique;
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/**
* unique an array
**/
let unique = function(arr) {
let hashTable = {};
let data = [];
for(let i=0,l=arr.length;i<l;i++) {
if(!hashTable[arr[i]]) {
hashTable[arr[i]] = true;
data.push(arr[i]);
}
}
return data
}
module.exports = unique;
|
成千上万个人获得那样的标题特别轻巧想到用for
将字符串颠倒字母顺序然后特出就行了。其实根本的观看比赛的正是对于reverse的贯彻。其实大家得以接纳现有的函数，将字符串转变来数组，那个思路很关键，大家能够具备愈来愈多的自由度去开展字符串的一部分操作。
回文是指把一样的词汇或句子，在下文中互交换一下地点置或颠倒过来，发生首尾回环的意味，叫做回文，也叫回环。例如mamam redivider .
非常多人获得如此的标题非常轻便想到用for
将字符串颠倒字母顺序然后卓越就行了。其实根本的观看比赛的正是对于reverse的达成。其实大家能够行使现有的函数，将字符串转变来数组，这几个思路非常重大，大家能够享有更加的多的自由度去开展字符串的一些操作。
基本上都交互性的操作，可是从各大公司面试来看，算法依旧是观测的一面。实际上学习数据结构与算法对于技术员去领会和剖析难点都以有辅助的。假若今后当我们面临较为复杂的主题材料，这么些基础知识的会集能够帮忙大家越来越好的优化解决思路。上面罗列在前面多个面试中平常遇上的多少个难题吧。
Q3 总结一个字符串出现最多的字母
交付一段英文连连的马耳他语字符窜，找寻重新现身次数最多的字母
输入 ： afjghdfraaaasdenas 输出 ： a
|
1
2
3
|
输入 ： afjghdfraaaasdenas
输出 ： a
|
前方出现过去重的算法，这里必要是总括重复次数。
JavaScript
function findMaxDuplicateChar(str) { if(str.length == 1) { return str; }
let charObj = {}; for(let i=0;i<str.length;i++) {
if(!charObj[str.charAt(i)]) { charObj[str.charAt(i)] = 1; }else{
charObj[str.charAt(i)] += 1; } } let maxChar = '', maxValue = 1;
for(var k in charObj) { if(charObj[k] >= maxValue) { maxChar = k;
maxValue = charObj[k]; } } return maxChar; } module.exports =
findMaxDuplicateChar;
|
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
|
function findMaxDuplicateChar(str) {
if(str.length == 1) {
return str;
}
let charObj = {};
for(let i=0;i<str.length;i++) {
if(!charObj[str.charAt(i)]) {
charObj[str.charAt(i)] = 1;
}else{
charObj[str.charAt(i)] += 1;
}
}
let maxChar = '',
maxValue = 1;
for(var k in charObj) {
if(charObj[k] >= maxValue) {
maxChar = k;
maxValue = charObj[k];
}
}
return maxChar;
}
module.exports = findMaxDuplicateChar;
|
function checkPalindrom(str) {
数不完人得到那般的难题特别轻易想到用for
将字符串颠倒字母顺序然后十三分就行了。其实首要的观测的正是对此reverse的兑现。其实大家能够利用现有的函数，将字符串转变到数组，这几个思路很关键，大家能够具备越多的自由度去进行字符串的一部分操作。
function checkPalindrom(str) {
Q4 排序算法
假定抽到算法题指标话，应该大致都是相比开放的难点，不限定算法的贯彻，但是不容置疑须求驾驭之中的三种，所以冒泡排序，这种相比较基础还要有利于明白回忆的算法一定需求熟记于心。冒泡排序算法就是逐一非常的大小，小的的大的进行岗位上的置换。
JavaScript
function bubbleSort(arr) { for(let i = 0,l=arr.length;i<l-1;i++) {
for(let j = i+1;j<l;j++) { if(arr[i]>arr[j]) { let tem =
arr[i]; arr[i] = arr[j]; arr[j] = tem; } } } return arr; }
module.exports = bubbleSort;
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
function bubbleSort(arr) {
for(let i = 0,l=arr.length;i<l-1;i++) {
for(let j = i+1;j<l;j++) {
if(arr[i]>arr[j]) {
let tem = arr[i];
arr[i] = arr[j];
arr[j] = tem;
}
}
}
return arr;
}
module.exports = bubbleSort;
|
除却冒泡排序外，其实还会有大多诸如
插入排序,迅猛排序，Hill排序等。每一项排序算法都有分别的表征。全部操纵也不需求，不过心里必定要熟识二种算法。
比如连忙排序，其效用非常高，而其基本原理如图(来自wiki)：
算法参照他事他说加以考察有个别成分值，将低于它的值，放到左数组中，大于它的值的成分就放置右数组中，然后递归进行上一遍左右数组的操作，重返合併的数组就是曾经排好顺序的数组了。
JavaScript
function quickSort(arr) { if(arr.length<=1) { return arr; } let
leftArr = []; let rightArr = []; let q = arr[0]; for(let i =
1,l=arr.length; i<l; i++) { if(arr[i]>q) {
rightArr.push(arr[i]); }else{ leftArr.push(arr[i]); } } return
[].concat(quickSort(leftArr),[q],quickSort(rightArr)); }
module.exports = quickSort;
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
function quickSort(arr) {
if(arr.length<=1) {
return arr;
}
let leftArr = [];
let rightArr = [];
let q = arr[0];
for(let i = 1,l=arr.length; i<l; i++) {
if(arr[i]>q) {
rightArr.push(arr[i]);
}else{
leftArr.push(arr[i]);
}
}
return [].concat(quickSort(leftArr),[q],quickSort(rightArr));
}
module.exports = quickSort;
|
安利我们三个就学的地点，通过动画演示算法的完结。
HTML5 Canvas Demo: Sorting
Algorithms
return str == str.split('').reverse().join('');
function checkPalindrom(str) {
return str == str.split('').reverse().join('');
Q5 不借助于有的时候变量，进行多少个整数的交流
输入 a = 2, b = 4 输出 a = 4, b =2
|
1
|
输入 a = 2, b = 4 输出 a = 4, b =2
|
这种主题材料特别抢眼，要求我们跳出惯有的思辨，利用 a , b进行交流。
注重是运用 + – 去开展览演出算，类似 a = a + ( b – a) 实际上一模二样最终 的 a =
b;
JavaScript
function swap(a , b) { b = b - a; a = a + b; b = a - b; return [a,b];
} module.exports = swap;
|
1
2
3
4
5
6
7
8
|
function swap(a , b) {
b = b - a;
a = a + b;
b = a - b;
return [a,b];
}
module.exports = swap;
|
}
return str == str.split('').reverse().join('');
}
Q1 推断三个单词是还是不是是回文？
Q6 使用canvas 绘制三个有限度的斐波那契数列的曲线？
数列长度限制在9.
斐波那契数列，又称白银分割数列，指的是如此贰个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列第一考查递归的调用。我们一般都知道定义
JavaScript
fibo[i] = fibo[i-1]+fibo[i-2];
|
1
|
fibo[i] = fibo[i-1]+fibo[i-2];
|
转移斐波那契数组的办法
JavaScript
function getFibonacci(n) { var fibarr = []; var i = 0; while(i<n) {
if(i<=1) { fibarr.push(i); }else{ fibarr.push(fibarr[i-1] +
fibarr[i-2]) } i++; } return fibarr; }
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
function getFibonacci(n) {
var fibarr = [];
var i = 0;
while(i<n) {
if(i<=1) {
fibarr.push(i);
}else{
fibarr.push(fibarr[i-1] + fibarr[i-2])
}
i++;
}
return fibarr;
}
|
剩下的劳作正是运用canvas arc方法进行曲线绘制了
DEMO
Q2 去掉一组整型数组重复的值
}
Q2 去掉一组整型数组重复的值
Q7 搜索下列正数组的最大差值比方:
输入 [10,5,11,7,8,9] 输出 6
|
1
2
3
|
输入 [10,5,11,7,8,9]
输出 6
|
那是由此一道标题去测量试验对于宗旨的数组的最大值的研究，很显著我们了解，最大差值明确是一个数组中最大值与最小值的差。
JavaScript
function getMaxProfit(arr) { var minPrice = arr[0]; var maxProfit = 0;
for (var i = 0; i < arr.length; i++) { var currentPrice = arr[i];
minPrice = Math.min(minPrice, currentPrice); var potentialProfit =
currentPrice - minPrice; maxProfit = Math.max(maxProfit,
potentialProfit); } return maxProfit; }
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
function getMaxProfit(arr) {
var minPrice = arr[0];
var maxProfit = 0;
for (var i = 0; i < arr.length; i++) {
var currentPrice = arr[i];
minPrice = Math.min(minPrice, currentPrice);
var potentialProfit = currentPrice - minPrice;
maxProfit = Math.max(maxProfit, potentialProfit);
}
return maxProfit;
}
|
比如说输入: [1,13,24,11,11,14,1,2]
Q2 去掉一组整型数组重复的值
诸如输入: [1,13,24,11,11,14,1,2]
回文是指把同样的词汇或句子，在下文中互交换一下地点置或颠倒过来，爆发首尾回环的野趣，叫做回文，也叫回环。举个例子mamam redivider .
Q8 随机变化钦点长度的字符串
贯彻三个算法，随机生成指制订长度的字符窜。
譬喻说给定 长度 8 输出 4ldkfg9j
|
1
|
比如给定 长度 8 输出 4ldkfg9j
|
JavaScript
function randomString(n) { let str =
'abcdefghijklmnopqrstuvwxyz9876543210'; let tmp = '', i = 0, l =
str.length; for (i = 0; i < n; i++) { tmp +=
str.charAt(Math.floor(Math.random() * l)); } return tmp; }
module.exports = randomString;
|
1
2
3
4
5
6
7
8
9
10
11
12
|
function randomString(n) {
let str = 'abcdefghijklmnopqrstuvwxyz9876543210';
let tmp = '',
i = 0,
l = str.length;
for (i = 0; i < n; i++) {
tmp += str.charAt(Math.floor(Math.random() * l));
}
return tmp;
}
module.exports = randomString;
|
输出: [1,13,24,11,14,2]
比如输入: [1,13,24,11,11,14,1,2]
输出: [1,13,24,11,14,2]
Q9 完成类似getElementsByClassName 的成效
和煦完毕二个函数，查找有个别DOM节点上边包车型地铁含有某些class的有所DOM节点？分裂意使用原生提供的
getElementsByClassName querySelectorAll 等原生提供DOM查找函数。
JavaScript
function queryClassName(node, name) { var starts = '(^|[
\n\r\t\f])', ends = '([ \n\r\t\f]|$)'; var array = [],
regex = new RegExp(starts + name + ends), elements =
node.getElementsByTagName("*"), length = elements.length, i = 0,
element; while (i < length) { element = elements[i]; if
(regex.test(element.className)) { array.push(element); } i += 1; }
return array; }
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
function queryClassName(node, name) {
var starts = '(^|[ \n\r\t\f])',
ends = '([ \n\r\t\f]|$)';
var array = [],
regex = new RegExp(starts + name + ends),
elements = node.getElementsByTagName("*"),
length = elements.length,
i = 0,
element;
while (i < length) {
element = elements[i];
if (regex.test(element.className)) {
array.push(element);
}
i += 1;
}
return array;
}
|
亟待去掉重复的11 和 1 那多个要素。
输出: [1,13,24,11,14,2]
亟需去掉重复的11 和 1 那多个要素。
很四人获得这么的主题材料特别轻巧想到用for
将字符串颠倒字母顺序然后非常就行了。其实主要的洞察的正是对此reverse的落到实处。其实大家得以使用现有的函数，将字符串调换到数组，那么些思路很要紧，大家得以具备更加多的自由度去举办字符串的有的操作。
Q10 使用JS 达成二叉查找树(Binary Search Tree)
一般叫全体写完的票房价值相当少，不过最首要着重你对它的了然和局地焦点特征的兑现。
二叉查找树，也称二叉寻找树、有序二叉树（乌克兰语：ordered binary
tree）是指一棵空树恐怕有所下列性质的二叉树：
- 自由节点的左子树不空，则左子树上全体结点的值均小于它的根结点的值；
- 大肆节点的右子树不空，则右子树上全数结点的值均超越它的根结点的值；
- 随意节点的左、右子树也独家为二叉查找树；
- 平昔不键值相等的节点。二叉查找树比较于任何数据结构的优势在于搜索、插入的时间复杂度好低。为O(log
n)。二叉查找树是基础性数据结构，用于构建特别抽象的数据结构，如会集、multiset、关联数组等。
在写的时候必要丰盛驾驭二叉搜素树的特色，供给先设定好每一个节点的数据结构
JavaScript
class Node { constructor(data, left, right) { this.data = data;
this.left = left; this.right = right; } }
|
1
2
3
4
5
6
7
8
|
class Node {
constructor(data, left, right) {
this.data = data;
this.left = left;
this.right = right;
}
}
|
树是有节点构成，由根节点逐步延生到各类子节点，因而它装有基本的组织便是具备二个根节点，具备丰硕，查找和删除节点的方法.
JavaScript
class BinarySearchTree { constructor() { this.root = null; }
insert(data) { let n = new Node(data, null, null); if (!this.root) {
return this.root = n; } let currentNode = this.root; let parent = null;
while (1) { parent = currentNode; if (data < currentNode.data) {
currentNode = currentNode.left; if (currentNode === null) { parent.left
= n; break; } } else { currentNode = currentNode.right; if (currentNode
=== null) { parent.right = n; break; } } } } remove(data) { this.root =
this.removeNode(this.root, data) } removeNode(node, data) { if (node ==
null) { return null; } if (data == node.data) { // no children node if
(node.left == null && node.right == null) { return null; } if (node.left
== null) { return node.right; } if (node.right == null) { return
node.left; } let getSmallest = function(node) { if(node.left === null &&
node.right == null) { return node; } if(node.left != null) { return
node.left; } if(node.right !== null) { return getSmallest(node.right); }
} let temNode = getSmallest(node.right); node.data = temNode.data;
node.right = this.removeNode(temNode.right,temNode.data); return node; }
else if (data < node.data) { node.left =
this.removeNode(node.left,data); return node; } else { node.right =
this.removeNode(node.right,data); return node; } } find(data) { var
current = this.root; while (current != null) { if (data == current.data)
{ break; } if (data < current.data) { current = current.left; } else
{ current = current.right } } return current.data; } } module.exports =
BinarySearchTree;
|
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
class BinarySearchTree {
constructor() {
this.root = null;
}
insert(data) {
let n = new Node(data, null, null);
if (!this.root) {
return this.root = n;
}
let currentNode = this.root;
let parent = null;
while (1) {
parent = currentNode;
if (data < currentNode.data) {
currentNode = currentNode.left;
if (currentNode === null) {
parent.left = n;
break;
}
} else {
currentNode = currentNode.right;
if (currentNode === null) {
parent.right = n;
break;
}
}
}
}
remove(data) {
this.root = this.removeNode(this.root, data)
}
removeNode(node, data) {
if (node == null) {
return null;
}
if (data == node.data) {
// no children node
if (node.left == null && node.right == null) {
return null;
}
if (node.left == null) {
return node.right;
}
if (node.right == null) {
return node.left;
}
let getSmallest = function(node) {
if(node.left === null && node.right == null) {
return node;
}
if(node.left != null) {
return node.left;
}
if(node.right !== null) {
return getSmallest(node.right);
}
}
let temNode = getSmallest(node.right);
node.data = temNode.data;
node.right = this.removeNode(temNode.right,temNode.data);
return node;
} else if (data < node.data) {
node.left = this.removeNode(node.left,data);
return node;
} else {
node.right = this.removeNode(node.right,data);
return node;
}
}
find(data) {
var current = this.root;
while (current != null) {
if (data == current.data) {
break;
}
if (data < current.data) {
current = current.left;
} else {
current = current.right
}
}
return current.data;
}
}
module.exports = BinarySearchTree;
|
一体化代码
Github
那道标题应时而生在非常多的前端面试题中，首要考查个人对Object的行使，利用key来扩充筛选。
急需去掉重复的11 和 1 那多少个要素。
那道难题应际而生在多数的前端面试题中，首要考查个人对Object的行使，利用key来张开筛选。
function checkPalindrom(str) {
扩展阅读
2 赞 12 收藏 7
评论
/**
那道标题出现在无尽的前端面试题中，首要考察个人对Object的运用，利用key来举行筛选。
/**
return str == str.split('').reverse().join('');
* unique an array
/**
* unique an array
}
**/
* unique an array
**/
let unique = function(arr) {
**/
let unique = function(arr) {
let hashTable = {};
let unique = function(arr) {
let hashTable = {};
Q2 去掉一组整型数组重复的值
let data = [];
let hashTable = {};
let data = [];
for(let i=0,l=arr.length;i
let data = [];
for(let i=0,l=arr.length;i
if(!hashTable[arr[i]]) {
for(let i=0,l=arr.length;i
if(!hashTable[arr[i]]) {
诸如输入: [1,13,24,11,11,14,1,2]
hashTable[arr[i]] = true;
if(!hashTable[arr[i]]) {
hashTable[arr[i]] = true;
输出: [1,13,24,11,14,2]
data.push(arr[i]);
hashTable[arr[i]] = true;
data.push(arr[i]);
急需去掉重复的11 和 1 那八个因素。
}
data.push(arr[i]);
}
}
}
}
这道难题应际而生在多数的前端面试题中，首要考查个人对Object的利用，利用key来张开筛选。
return data
}
return data
/**
}
return data
}
* unique an array
module.exports = unique;
}
module.exports = unique;
**/
Q3 总计一个字符串出现最多的字母
module.exports = unique;
Q3 总结二个字符串出现最多的字母
let unique = function(arr) {
交付一段土耳其共和国（The Republic of Turkey）语连连的匈牙利（Hungary）语字符窜，寻找重新现身次数最多的字母
Q3 计算二个字符串出现最多的假名
交付一段英语连连的罗马尼亚语字符窜，寻觅重新出现次数最多的假名
let hashTable = {};
输入 ： afjghdfraaaasdenas
付给一段土耳其（Turkey）语连连的英文字符窜，找寻重新出现次数最多的假名
输入 ： afjghdfraaaasdenas
let data = [];
输出 ： a
输入 ： afjghdfraaaasdenas
输出 ： a
for(let i=0,l=arr.length;i<l;i++) {
前方出现过去重的算法，这里需假如计算重复次数。
输出 ： a
前方出现过去重的算法，这里需倘若总结重复次数。
if(!hashTable[arr[i]]) {
function findMaxDuplicateChar(str) {
function findMaxDuplicateChar(str) {
function findMaxDuplicateChar(str) {
hashTable[arr[i]] = true;
if(str.length == 1) {
if(str.length == 1) {
if(str.length == 1) {
data.push(arr[i]);
return str;
return str;
return str;
}
}
}
}
}
let charObj = {};
let charObj = {};
let charObj = {};
return data
for(let i=0;i
for(let i=0;i
for(let i=0;i
if(!charObj[str.charAt(i)]) {
if(!charObj[str.charAt(i)]) {
if(!charObj[str.charAt(i)]) {
}
charObj[str.charAt(i)] = 1;
charObj[str.charAt(i)] = 1;
charObj[str.charAt(i)] = 1;
}else{
}else{
}else{
module.exports = unique;
charObj[str.charAt(i)] += 1;
charObj[str.charAt(i)] += 1;
charObj[str.charAt(i)] += 1;
}
}
}
Q3 总计一个字符串出现最多的假名
}
}
}
let maxChar = '',
let maxChar = '',
let maxChar = '',
交付一段日文连连的斯拉维尼亚语字符窜，找寻重新出现次数最多的假名
maxValue = 1;
maxValue = 1;
maxValue = 1;
输入 ： afjghdfraaaasdenas
for(var k in charObj) {
for(var k in charObj) {
for(var k in charObj) {
if(charObj[k] >= maxValue) {
if(charObj[k] >= maxValue) {
if(charObj[k] >= maxValue) {
输出 ： a
maxChar = k;
maxChar = k;
maxChar = k;
前面出现过去重的算法，这里需假使总计重复次数。
maxValue = charObj[k];
maxValue = charObj[k];
maxValue = charObj[k];
function findMaxDuplicateChar(str) {
}
}
}
if(str.length == 1) {
}
}
}
return str;
return maxChar;
return maxChar;
return maxChar;
}
}
}
}
let charObj = {};
module.exports = findMaxDuplicateChar;
module.exports = findMaxDuplicateChar;
module.exports = findMaxDuplicateChar;
for(let i=0;i<str.length;i++) {
Q4 排序算法
Q4 排序算法
Q4 排序算法
if(!charObj[str.charAt(i)]) {
一旦抽到算法题指标话，应该大致都以相比开放的问题，不限定算法的达成，可是必需要求调整之中的二种，所以冒泡排序，这种较为基础还要有利于驾驭记念的算法一定必要熟记于心。冒泡排序算法正是各种比非常大小，小的的大的进展岗位上的调换。
即使抽到算法标题的话，应该差不离都以比较开放的主题材料，不限定算法的完成，可是确实无疑要求精通之中的二种，所以冒泡排序，这种相比较基础还要有助于了解记念的算法一定需求熟记于心。冒泡排序算法正是逐条相当的大小，小的的大的打开岗位上的置换。
要是抽到算法题指标话，应该大概都以相比较开放的主题材料，不限定算法的兑现，可是没有什么可争辨的必要明白之中的二种，所以冒泡排序，这种比较基础还要有助于领会纪念的算法一定必要熟记于心。冒泡排序算法正是逐条十分大小，小的的大的进展岗位上的置换。
charObj[str.charAt(i)] = 1;
function bubbleSort(arr) {
function bubbleSort(arr) {
function bubbleSort(arr) {
}else{
for(let i = 0,l=arr.length;i
for(let i = 0,l=arr.length;i
for(let i = 0,l=arr.length;i
charObj[str.charAt(i)] += 1;
for(let j = i+1;j
for(let j = i+1;j
for(let j = i+1;j
}
if(arr[i]>arr[j]) {
if(arr[i]>arr[j]) {
if(arr[i]>arr[j]) {
}
let tem = arr[i];
let tem = arr[i];
let tem = arr[i];
let maxChar = '',
arr[i] = arr[j];
arr[i] = arr[j];
arr[i] = arr[j];
maxValue = 1;
arr[j] = tem;
arr[j] = tem;
arr[j] = tem;
for(var k in charObj) {
}
}
}
if(charObj[k] >= maxValue) {
}
}
}
maxChar = k;
}
}
}
maxValue = charObj[k];
return arr;
return arr;
return arr;
}
}
}
}
}
转载本站文章请注明出处：vns威尼斯城官网登入 http://www.tiec-ccpittj.com/?p=2379