前端常用的一些算法

/*去重*/

function delRepeat(arr){

var newArray=new Array();

var len=arr.length;

for(var i=0;i

for(var j=i+1;j

{

if(arr[i]==arr[j])

{

++i;

}

}

newArray.push(arr[i]);

}

return newArray;

}

var arr=new Array("red","red","1","5","2");

alert(delRepeat(arr));

/*二分法*/

又稱為折半查找算法，但是有缺陷就是要求數字是預先排序好的

function binary(items,value){

var startIndex=0,

stopIndex=items.length-1,

midlleIndex=(startIndex+stopIndex)>>>1;

while(items[middleIndex]!=value && startIndex

if(items[middleIndex]>value){

stopIndex=middleIndex-1;

}else{

startIndex=middleIndex+1;

}

middleIndex=(startIndex+stopIndex)>>>1;

}

return items[middleIndex]!=value ? false:true;

}

/*十六進制顏色值的隨機生成*/

function randomColor(){

var arrHex=["0","2","3","4","5","6","7","8","9","a","b","c","d"],

strHex="#",

index;

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

index=Math.round(Math.random()*15);

strHex+=arrHex[index];

}

return strHex;

}

/*一個求字符串長度的方法*/

function GetBytes(str){

var len=str.length,

bytes=len;

for(var i=0;i

if(str.CharCodeAt>255){

bytes++;

}

}

return bytes;

}

/*插入排序*/

所謂的插入排序，就是將序列中的第一個元素看成一個有序的子序列，然后不段向后比較交換比較交換。

function insertSort(arr){

var key;

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

//排好序的

var i = j - 1;

key = arr[j];

while(i >= 0 && arr[i] > key){

arr[i + 1] = arr[i];

i --;

}

arr[i + 1] = key;

}

return arr;

}

/*希爾排序*/

希爾排序，也稱遞減增量排序算法

其實說到底也是插入排序的變種

function shellSort(array){

var stepArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1]; // reverse()在維基上看到這個最優的步長較小數組

var i = 0;

var stepArrLength = stepArr.length;

var len = array.length;

var len2 = ?parseInt(len/2);

for(;i < stepArrLength; i++){

if(stepArr[i] > len2){

continue;

}

stepSort(stepArr[i]);

}

//排序一個步長

function stepSort(step){

//console.log(step)使用的步長統計

var i = 0, j = 0, f, tem, key;

var stepLen = len%step > 0 ? ?parseInt(len/step) + 1 : len/step;

for(;i < step; i++){//依次循環列

for(j=1;/*j < stepLen && */step * j + i < len; j++){//依次循環每列的每行

tem = f = step * j + i;

key = array[f];

while((tem-=step) >= 0){//依次向上查找

if(array[tem] > key){

array[tem+step] = array[tem];

}else{

break;

}

}

array[tem + step ] = key;

}

}

}

return array;

}

/*快速排序*/

快速排序算法就系對冒泡排序的一種改進，采用的就是算法理論中的分治遞歸的思想。

具體做法：通過一趟排序將待排序的紀錄分割成兩部分，其中一部分的紀錄值比另外一部分的紀錄值要小，就可以繼續分別對這兩部分紀錄進行排序；不段的遞歸實施上面兩個操作，從而實現紀錄值的排序。

function sort(arr){

return quickSort(arr,0,arr.length-1);

function quickSort(arr,l,r){

if(l

var mid=arr[parseInt((l+r)/2)],i=l-1,j=r+1;

while(true){

//大的放到右邊，小的放到左邊, i與j均為游標

while(arr[++i]

while(arr[--j]>mid);

if(i>=j)break;//判斷條件

var temp = arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

quickSort(arr,l,i-1);

quickSort(arr,j+1,r);

}

return arr;

}

}

function main(){

var list=new Array(49,38,65,97,76,13,27);

document.write(sort(list).valueOf());

}

main();

/*冒泡法*/

function bullSort(array){

var temp;

for(var i=0;i

for(var j=array.length-1;j>i;j--){

if(array[j]

temp = array[j];

array[j]=array[j-1];

array[j-1]=temp;

}

}

}

return array;

}

/*js遞歸實現方案*/

遞歸函數是在一個函數通過調用自身的情況下去解決的：

方式如下：

function factorial(num){

if(num<=1){

return 1;

}else{

return num*factorial(num-1);

}

}

但是這在js里面可能會出現錯誤：

var anotherFactorial = factorial;

factorial=null;

alert(anoterFactorial(4));

因為在調用anoterFactorial時內部的factorial已經不存在了。

解決方法是通過arguments.callee來解決。

如下：

function factorial(num){

if(num<=1){

return 1;

}else{

return num*arguments.callee(num-1);

}

var anotherFactorial = factorial;

factorial = null;

alert(anotherFactorial(4));

成功！！！！

}

/**js模擬多線程**/

if (Array.prototype.shift==null)

Array.prototype.shift = function (){

var rs = this[0];

for (var i=1;i

this.length=this.length-1

return rs;

}

if (Array.prototype.push==null)

Array.prototype.push = function (){

for (var i=0;i

return this.length;

}

var commandList = [];

var nAction = 0;//控制每次運行多少個動作

var functionConstructor = function(){}.constructor;

function executeCommands(){

for (var i=0;i

if (commandList.length>0){

var command = commandList.shift();

if (command.constructor == functionConstructor)

if (command.scheduleTime == null || new Date()-command.scheduleTime>0)

command();

else

commandList.push(command);

}

}

function startNewTask(){

var resultTemp = document.getElementById("sampleResult").cloneNode(true);

with (resultTemp){

id="";style.display="block";style.color=(Math.floor(Math.random()* (1<<23)).toString(16)+"00000").substring(0,6);

}

document.body.insertBefore(resultTemp,document.body.lastChild);

commandList.push(function(){simThread(resultTemp,1);});

nAction++;

}

function ?simThread(temp,n){

if (temp.stop) n--;

else temp.innerHTML = temp.innerHTML - (-n);

if (n<1000)

commandList.push(function(){simThread(temp,++n)});

else{

var command = function(){document.body.removeChild(temp);;nAction--;};

command.scheduleTime = new Date()-(-2000);

commandList.push(command);

}

}

window.onload = function(){setInterval("executeCommands()",1);}

/

/*選擇法排序*/

選擇法主要有三種：

《1》簡單的選擇排序：簡單的前后交互。

/*簡單選擇法排序*/

其實基本的思想就是從待排序的數組中選擇最小或者最大的，放在起始位置，然后從剩下的數組中選擇最小或者最大的排在這公司數的后面。

function selectionSort(data)

{

var i, j, min, temp , count=data.length;

for(i = 0; i < count - 1; i++) {

/* find the minimum */

min = i;

for (j = i+1; j < count; j++)

{ ? ?if (data[j] < data[min])

{ min = j;}

}

/* swap data[i] and data[min] */

temp = data[i];

data[i] = data[min];

data[min] = temp;

}

return data;

}

《2》樹型排序：又稱錦標賽排序，首先對n個元素進行兩兩比較，然后在其中[n/2]個較小者再進行兩兩比較如此重復直至選出最小的關鍵字的紀錄為止。（可用完全二差樹表示）。缺點：輔助空間需求過大，和“最大值”進行多余比較

《3》堆排序：（不適用于紀錄數較少的文件）

堆排序算法的過程如下:

1)得到當前序列的最小(大)的元素

2)把這個元素和最后一個元素進行交換,這樣當前的最小(大)的元素就放在了序列的最后,而原先的最后一個元素放到了序列的最前面

3)的交換可能會破壞堆序列的性質(注意此時的序列是除去已經放在最后面的元素),因此需要對序列進行調整,使之滿足于上面堆的性質.

重復上面的過程,直到序列調整完畢為止.

js實現：

/**

*堆排序

* @param items數組

* @return排序后的數組

*/

function heapSort(items)

{

items = array2heap(items); //將數組轉化為堆

for(var i = items.length - 1; i >= 0; i--)

{

items = swap(items, 0, i); //將根和位置i的數據交換(用于將最大值放在最后面)

items = moveDown(items, 0, i - 1); //數據交換后恢復堆的屬性

}

return items;

}

/**

*將數組轉換為堆

* @param items數組

* @return堆

*/

function array2heap(items)

{

for(var i = Math.ceil(items.length / 2) - 1; i >= 0; i--)

{

items = moveDown(items, i, items.length - 1); //轉換為堆屬性

}

return items;

}

/**

*轉換為堆

* @param items數組

* @param first第一個元素

* @param last最后一個元素

* @return堆

*/

function moveDown(items, first, last)

{

var largest = 2 * first + 1;

while(largest <= last)

{

if(largest < last && items[largest] < items[largest + 1])

{

largest++;

}

if(items[first] < items[largest])

{

items = swap(items, first, largest); //交換數據

first = largest; ? //往下移

largest = 2 * first + 1;

}

else

{

largest = last + 1; //跳出循環

}

}

return items;

}

/**

*交換數據

* @param items數組

* @param index1索引1

* @param index2索引2

* @return數據交換后的數組

*/

function swap(items, index1, index2)

{

var tmp = items[index1];

items[index1] = items[index2];

items[index2] = tmp;

return items;

}

var a = [345,44,6,454,10,154,3,12,11,4,78,9,0,47,88,9453,4,65,1,5];

document.write(heapSort(a));

所謂歸并就是將兩個或者兩個以上的有序表合成一個新的有序表。

遞歸形式的算法在形式上較為簡潔但實用性較差，與快速排序和堆排序相比，歸并排序的最大特點是，它是一種穩定的排序方法。

js實現歸并：

function MemeryArray(Arr,n, Brr, m)

{ ? ?? var i, j, k;

var Crr=new Array();

i = j = k = 0;

while (i < n && j < m)

{

if (Arr[i] < Brr[j])

Crr[k++] = Arr[i++];

else

Crr[k++] = Brr[j++];

}

while (i < n)

Crr[k++] = Arr[i++];

while (j < m)

Crr[k++] = Brr[j++];

return Crr;

}

var Arr=new Array(45,36,89,75,65);

var Brr=new Array(48,76,59,49,25);

alert(MemeryArray(Arr , Arr.length , Brr , Brr.length));

歸并排序待續，先睡了：

歸并排序：

//將有二個有序數列a[first...mid]和a[mid...last]合并。

function mergearray(Arr,first,mid,last,tempArr)

{

var i = first, j = mid + 1;

var m = mid, ? n = last;

var k = 0;

while (i <= m && j <= n)

{

if (Arr[i] < Arr[j])

tempArr[k++] = Arr[i++];

else

tempArr[k++] = Arr[j++];

}

while (i <= m)

tempArr[k++] = Arr[i++];

while (j <= n)

tempArr[k++] = Arr[j++];

for (i = 0; i < k; i++)

Arr[first + i] = tempArr[i];

}

function mergesort(Arr,first,last)

{

var tempArr=new Array();

if (first < last)

{

var mid = (first + last)>>>1;

mergesort(Arr, first, mid, tempArr); ? ?//左邊有序

mergesort(Arr, mid + 1, last, tempArr); ?//右邊有序

mergearray(Arr, first, mid, last, tempArr); ?//再將二個有序數列合并

}

return ?Arr;

}

var Arr=new Array(1,65,45,98,56,78);

alert(mergesort(Arr,0,Arr.length-1));

/*比較兩個字符串的相似性－Levenshtein算法簡介*/

問題與描述：

近似字符串匹配問題

說明：設給定樣本，對于任意文本串，樣本P在文本T中的K-近似匹配（K-approximate match）是指P在T中包含最多K個差異的匹配，這里的差別指：

（1）修改：P與T中對應的字符不同

（2）刪除：T中含有一個未出現在P中的字符

（3）插入：T中不包含出現在P中的一個字符

（也就是編輯距離問題）

例如：

T: a p r o x i o m a l l y

P: a p p r o x i m a t l y

經過1：插入2：刪除3：修改

那么就是一個3-近似問題

事實上，兩個字符串可能有不得出不同的差別數量，所以K-近似匹配要求：

（1）差別數最多為K個

（2）差別數為所有匹配方式下最少的稱為編輯距離

（字符串T到P最少的差別數稱為T和P的編輯距離）

試驗要求：

（1）利用動態規劃方法給出兩個字符串編輯距離的算法

（2）分析復雜度

（3）考慮其它方法

Levenshtein Distance來文史特距離

goodzzp

LD也叫edit distance，它用來表示2個字符串的相似度，不同于Hamming Distance，它可以用來比較2個長度不同的字符串。LD定義為需要最少多少步基本操作才能讓2個字符串相等，基本操作包含3個：

1，插入；

2，刪除；

3，替換；

比如，kiteen和sitting之間的距離可以這么計算：

1，kitten – > sitten,替換k為s；

2，sitten – > sittin,替換e為i;

3，sittin – > sitting,增加g；

所以，其LD為3；

計算LD的算法表示為：

int LevenshteinDistance(char str1[1..lenStr1], char str2[1..lenStr2])

// d is a table with lenStr1+1 rows and lenStr2+1 columns

declare int d[0..lenStr1, 0..lenStr2]

// i and j are used to iterate over str1 and str2

declare int i, j, cost

for i from 0 to lenStr1

d[i, 0] := i

for j from 0 to lenStr2

d[0, j] := j

for i from 1 to lenStr1

for j from 1 to lenStr2

if str1[i] = str2[j] then cost := 0

else cost := 1

d[i, j] := minimum(

d[i-1, j ] + 1,// deletion

d[i , j-1] + 1,// insertion

d[i-1, j-1] + cost// substitution

)

return d[lenStr1, lenStr2]；

這個算法其實就是一個矩陣的計算：

k i t t e n

0 1 2 3 4 5 6

s 1 1 2 3 4 5 6

i 2 2 1 2 3 4 5

t 3 3 2 1 2 3 4

t 4 4 3 2 1 2 3

i 5 5 4 3 2 2 3

n 6 6 5 4 3 3 2

g 7 7 6 5 4 4 3

首先給定第一行和第一列，然后，每個值d[i,j]這樣計算：d[i,j] = min(d[i-1,j]+ 1,d[i,j-1] +1,d[i-1,j-1]+(str1[i] == str2[j]?0:1));

最后一行，最后一列的那個值就是LD的結果。

LD(str1,str2) <= max(str1.len,str2.len)；

有人提出了Levenshtein automaton（Levenshtein自動機）來計算和某個字符串距離小于某個值的集合。這樣能夠加快近似字符串的計算過程。見文獻：Klaus U. Schulz, Stoyan Mihov, Fast String Correction with Levenshtein-Automata. International Journal of Document Analysis and Recognition, 5(1):67--85, 2002.

A Guided Tour to Approximate String MatchingGONZALONAVARRO

這篇文章里面對這個方面（字符串相似）進行了很多描述。其中，包含了動態規劃法計算Edit distance的方法。

js實現：

//求兩個字符串的相似度,返回差別字符數,Levenshtein Distance算法實現

function Levenshtein_Distance(s,t){

var n=s.length;// length of s

var m=t.length;// length of t

var d=[];// matrix

var i;// iterates through s

var j;// iterates through t

var s_i;// ith character of s

var t_j;// jth character of t

var cost;// cost

// Step 1

if (n == 0) return m;

if (m == 0) return n;

// Step 2

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

d[i]=[];

d[i][0] = i;

}

for (j = 0; j <= m; j++) {

d[0][j] = j;

}

// Step 3

for (i = 1; i <= n; i++) {

s_i = s.charAt (i - 1);

// Step 4

for (j = 1; j <= m; j++) {

t_j = t.charAt (j - 1);

// Step 5

if (s_i == t_j) {

cost = 0;

}else{

cost = 1;

}

// Step 6

d[i][j] = Minimum (d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1] + cost);

}

}

// Step 7

return d[n][m];

}

//求兩個字符串的相似度,返回相似度百分比

function Levenshtein_Distance_Percent(s,t){

var l=s.length>t.length?s.length:t.length;

var d=Levenshtein_Distance(s,t);

return (1-d/l).toFixed(4);

}

//求三個數字中的最小值

function Minimum(a,b,c){

return a

}

var str1="ddsddf",str2="xdsfsx";

alert(Levenshtein_Distance_Percent(str1,str2));

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
    沈念sama閱讀 228,786評論 6贊 534
  • 死咒
    序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
    沈念sama閱讀 98,656評論 3贊 419
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
    開封第一講書人閱讀 176,697評論 0贊 379
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經常有香客問我，道長，這世上最難降的妖魔是什么？ 我笑而不...
    開封第一講書人閱讀 63,098評論 1贊 314
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
    茶點故事閱讀 71,855評論 6贊 410
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布。 她就那樣靜靜地躺著，像睡著了一般。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發上，一...
    開封第一講書人閱讀 55,254評論 1贊 324
  • 城市分裂傳說
    那天，我揣著相機與錄音，去河邊找鬼。 笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。 我是一名探鬼主播，決...
    沈念sama閱讀 43,322評論 3贊 442
  • 雙鴛鴦連環套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
    開封第一講書人閱讀 42,473評論 0贊 289
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
    沈念sama閱讀 49,014評論 1贊 335
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內容為張勛視角 年9月15日...
    茶點故事閱讀 40,833評論 3贊 355
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。 大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 43,016評論 1贊 371
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
    沈念sama閱讀 38,568評論 5贊 362
  • ?日本核電站爆炸內幕
    正文 年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
    茶點故事閱讀 44,273評論 3贊 347
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 34,680評論 0贊 26
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 35,946評論 1贊 288
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。 一個月前我還...
    沈念sama閱讀 51,730評論 3贊 393
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 48,006評論 2贊 374

推薦閱讀更多精彩內容

  • 背景 一年多以前我在知乎上答了有關LeetCode的問題, 分享了一些自己做題目的經驗。 張土汪：刷leetcod...
    土汪閱讀 12,762評論 0贊 33
  • 某次二面時，面試官問起Js排序問題，吾絞盡腦汁回答了幾種，深感算法有很大的問題，所以總計一下！ 排序算法說明 （1...
    流浪的先知閱讀 1,202評論 0贊 4
  • 為了星巴克的手帳咖啡過量了，原來喝三杯咖啡能秒睡的我卻失眠了大半夜。心塞……恰好被一個不熟的小妹子聽見了，便開展了...
    痛飲浮生閱讀 1,408評論 0贊 1
  • 我曾溫熱過一碗酒，你恣意端起一飲而盡， 竟是命定的相遇。 我曾苦苦祈求上蒼，讓我今生遇見你， 怎知這般不易。 我曾...
    風與月閱讀 256評論 0贊 1
  • 晨霧輕薄幽村墟，青灘綴珠白露稀。 遠山松林影朦朧，獨行獨性已忘機。
    葉落歲暮閱讀 178評論 1贊 0