算法基础之经典算法(1)

数据结构及基本排序、查找算法

这个部分内容比较多，请查看一下博客：

• 基于 Javascript 的排序算法

• 基于 javascript 的基本数据结构和查找算法

递归实现斐波那契数列

function reFib(n){

if (n < 2) return n;

else return reFib(n - 1) + reFib(n - 2);

}

动态规划实现斐波那契数列

function dynFib(n){

var val = [];

for(var i = 0; i <= n; i++)

val.push(0);

if (n == 1 || n == 2) return 1;

else{

val[1] = 1;

val[2] = 2;

for (var i = 3; i <= n; ++i)

val[i] = val[i - 1] + val[i - 2];

return val[n - 1];

}

}

迭代实现斐波那契数列

function iterFib(n){ //得到第n个数列值

var a = 1, b = 1, temp;

for(var i = 2; i <= n; i++){

temp = b;

b = a + b;

a = temp;

}

return a;

}

迭代实现斐波那契数列 ES6

function* fibs(){

let a = 1;

let b = 1;

while(1){

yield a;

[a, b] = [a, a + b];

}

}

var [first, second, third, forth, fifth, sixth] = fibs();

数组元素去重复

function unique(arr) {

return arr.filter(function(item, index){

return arr.indexOf(item) === index;

});

} //除去所以 undefined

//以下是 ES6 方法

function unique(arr){

return Array.from(new Set(arr));

} //保留数组中的 undefined

Fisher Yates Shuffle

Array.prototype.shuffle = function(){

var len = this.length;

for(var i = len - 1; i > 0; i–){

var j = Math.round(Math.random() * i);

// debugger;

[this[i],this[j]] = [this[j],this[i]];

}

return this;

}

查找2个字符串的最长公共子串

function lcs(word1, word2){

var max = 0;

var index = 0;

var lcsarr = [];

var str = “”;

for(var i = 0; i <= word1.length + 1; ++i){

lcsarr[i] = [];

for(var j = 0; j <= word2.length + 1; ++i)

lcsarr[i][j] = 0;

}

for(var i = 1; i <= word1.length; ++i){

for(var j = 1; j <= word2.length; ++j){

if(word1[i - 1] === word2[j - 1])

lcsarr[i][j] = lcsarr[i - 1][j - 1] + 1;

if(max < lcsarr[i][j]){

max = lcsarr[i][j];

index = i;

}

}

}

if(max === 0)

return “”;

else {

for(var i = index - max; i < index; ++i)

str += word1[i];

return str;

}

}

背包问题 递归

/**

• [knapsack description]

• @param number capacity 背包容量（最大承重）

• @param array weights 背包内物品重量

• @param array value 物品对应的价值

• @param number n 物品数量

• @return number 求的的最大价值

*/

function knapsack(capacity, weights, value, n){

if(n === 0 || capacity === 0) return 0;

if(weights[n -1] > capacity) return knapsack(capacity, weights, value, n - 1);

else return Math.max(value[n - 1] + knapsack(capacity - weights[n - 1], weights, value, n - 1), knapsack(capacity, weights, value, n - 1));

}

背包问题 动态规划

/**

• [knapsack description]

• @param number capacity 背包容量（最大承重）

• @param array weights 背包内物品重量

• @param array value 物品对应的价值

• @param number n 物品数量

• @return number 求的的最大价值

*/

function dKnapsack(capacity, weights, value, n){

var K = []; //价格矩阵

for(var i = 0; i <= n; i++)

K[i] = [];

for(var i = 0; i <= n; i++){

for(var w = 0; w <= capacity; w++){

if(i == 0 || w == 0)

K[i][w] = 0;

else if(weights[i - 1] <= w)

K[i][w] = Math.max(value[i - 1] + K[i - 1][w - weights[i - 1]], K[i - 1][w]);

else

K[i][w] = K[i - 1][w];

console.log(K[i][w] + " ");

}

console.log();

}

return K[n][capacity];

}

背包问题 贪心法

/**

• [knapsack description]

• @param number capacity 背包容量（最大承重）

• @param array weights 背包内物品重量

• @param array value 物品对应的价值

• @return number 求的的最大价值

*/

function dKnapsack(capacity, weights, values){

var load = 0;

var i = 0;

var w = 0;

while(load < capacity && i < 4){

if(weight[i] <= (capacity - load)){

w += value[i];

load += weight[i];

} else {

var r = (capacity - load) / weight[i];

w += r * value[i];

load += weights[i];

}

++i;

}

return w;

}

找零问题 贪心法

function makeChange(origAmt, coins){

var remainAmt = 0;

if(origAmt % .25 < origAmt){

coins[3] = parseInt(origAmt / .25);

remainAmt = origAmt % .25;

origAmt = remainAmt;

}

if(origAmt % .1 < origAmt){

coins[2] = parseInt(origAmt / .1);

最后

好了，这就是整理的前端从入门到放弃的学习笔记，还有很多没有整理到，我也算是边学边去整理，后续还会慢慢完善，这些相信够你学一阵子了。

做程序员，做前端工程师，真的是一个学习就会有回报的职业，不看出身高低，不看学历强弱，只要你的技术达到应有的水准，就能够得到对应的回报。

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

学习从来没有一蹴而就，都是持之以恒的，正所谓活到老学到老，真正懂得学习的人，才不会被这个时代的洪流所淘汰。