javascript常用经典算法实例详解

再来看看经典的多项式求值问题：

给定一串实数An，An-1，...，A1，A0 和一个实数X，计算多项式Pn(x)的值

著名的Horner公式：

已经如何计算：

显然有：

这样只需要 N次乘法+N次加法

1 2 3 4 5 6 7 8 9 10 11 12 13 14

//多项式求值 //N次乘法+N次加法搞定，伟大的改进！ function horner(A, x) {    var n = A.length - 1    var p = A[n];    for ( var j = 0; j < n; j++) {      p = x * p + A[n - j - 1];    }    return p; } //计算: y(2) = 3x^3 + 2x^2 + x -1; var A = [-1, 1, 2, 3]; var y = horner(A, 2); alert(y); //33

多数问题：

一个元素个数为n的数组，希望快速找出其中大于出现次数>n/2的元素（该元素也称为多数元素）。通常可用于选票系统，快速判定某个候选人的票数是否过半。最优算法如下：

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

//找出数组A中“可能存在”的多数元素 function candidate(A, m) {    var count = 1, c = A[m], n = A.length - 1;    while (m < n && count > 0) {      m++;      if (A[m] == c) {        count++;      }      else {        count--;      }    }    if (m == n) {      return c;    }    else {      return candidate(A, m + 1);    } } //寻找多数元素 //时间复杂度O(n) function majority(A) {    var c = candidate(A, 0);    var count = 0;    //找出的c，可能是多数元素，也可能不是，    //必须再数一遍，以确保结果正确    for ( var i = 0; i < A.length; i++) {      if (A[i] == c) {        count++;      }    }    //如果过半，则确定为多数元素    if (count > Math.floor(A.length / 2)) {      return c;    }    return null ; } var m = majority([3, 2, 3, 3, 4, 3]); alert(m);

以上算法基于这样一个结论：在原序列中去除两个不同的元素后，那么在原序列中的多数元素在新序列中还是多数元素

证明如下：

如果原序列的元素个数为n，多数元素出现的次数为x，则 x/n > 1/2
去掉二个不同的元素后，
a)如果去掉的元素中不包括多数元素，则新序列中 ，原先的多数元素个数/新序列元素总数 = x/(n-2) ，因为x/n > 1/2 ，所以 x/(n-2) 也必然>1/2
b)如果去掉的元素中包含多数元素，则新序列中 ，原先的多数元素个数/新序列元素总数 = (x-1)/(n-2) ，因为x/n > 1/2  =》 x>n/2 代入 (x-1)/(n-2) 中，
有 (x-1)/(n-2) > (n/2 -1)/(n-2) = 2(n-2)/(n-2) = 1/2

下一个问题：全排列

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

function swap(A, i, j) {    var t = A[i];    A[i] = A[j];    A[j] = t; } function println(msg) {    document.write(msg + "<br/>" ); } //全排列算法 function perm(P, m) {    var n = P.length - 1;    if (m == n) {      //完成一个新排列时，输出      println(P);      return ;    }    for ( var j = m; j <= n; j++) {      //将起始元素与后面的每个元素交换      swap(P, j, m);      //在前m个元素已经排好的基础上      //再加一个元素进行新排列      perm(P, m + 1);      //把j与m换回来，恢复递归调用前的“现场"，      //否则因为递归调用前，swap已经将原顺序破坏了，      //导致后面生成排序时，可能生成重复      swap(P, j, m);    } } perm([1, 2, 3], 0); //1,2,3 //1,3,2 //2,1,3 //2,3,1 //3,2,1 //3,1,2

分治法：

要点：将问题划分成二个子问题时，尽量让子问题的规模大致相等。这样才能最大程度的体现一分为二，将问题规模以对数折半缩小的优势。

//打印输出(调试用) function println(msg) {    document.write(msg + "<br/>" ); } //数组中i,j位置的元素交换(辅助函数) function swap(A, i, j) {    var t = A[i];    A[i] = A[j];    A[j] = t; } //寻找数组A中的最大、最小值(分治法实现) function findMinMaxDiv(A, low, high) {    //最小规模子问题的解    if (high - low == 1) {      if (A[low] < A[high]) {        return [A[low], A[high]];      }      else {        return [A[high], A[low]];      }    }    var mid = Math.floor((low + high) / 2);    //在前一半元素中寻找子问题的解    var r1 = findMinMaxDiv(A, low, mid);    //在后一半元素中寻找子问题的解    var r2 = findMinMaxDiv(A, mid + 1, high);    //把二部分的解合并    var x = r1[0] > r2[0] ? r2[0] : r1[0];    var y = r1[1] > r2[1] ? r1[1] : r2[1];    return [x, y]; } var r = findMinMaxDiv([1, 2, 3, 4, 5, 6, 7, 8], 0, 7); println(r); //1,8 //二分搜索(分治法实现) //输入：A为已按非降序排列的数组 //x 为要搜索的值 //low,high搜索的起、止索引范围 //返回：如果找到，返回下标，否则返回-1 function binarySearchDiv(A, x, low, high) {    if (low > high) {      return -1;    }    var mid = Math.floor((low + high) / 2);    if (x == A[mid]) {      return mid;    }    else if (x < A[mid]) {      return binarySearchDiv(A, x, low, mid - 1);    }    else {      return binarySearchDiv(A, x, mid + 1, high);    } } var f = binarySearchDiv([1, 2, 3, 4, 5, 6, 7], 4, 0, 6); println(f); //3 //将数组A，以low位置的元素为界，划分为前后二半 //n为待处理的索引范围上限 function split(A, low, n) {    if (n >= A.length - 1) {      n = A.length - 1;    }    var i = low;    var x = A[low];    //二个指针一前一后“跟随”，    //最前面的指针发现有元素比分界元素小时，换到前半部    //后面的指针再紧跟上，“夫唱妇随”一路到头    for ( var j = low + 1; j <= n; j++) {      if (A[j] <= x) {        i++;        if (i != j) {          swap(A, i, j);        }      }    }    //经过上面的折腾后，除low元素外，其它的元素均以就位    //最后需要把low与最后一个比low位置小的元素交换，    //以便把low放在分水岭位置上    swap(A, low, i);    return [A, i]; } var A = [5, 1, 2, 6, 3]; var b = split(A, 0, A.length - 1); println(b[0]); //3,1,2,5,6 //快速排序 function quickSort(A, low, high) {    var w = high;    if (low < high) {      var t = split(A, low, w); //分治思路，先分成二半      w = t[1];      //在前一半求解      quickSort(A, low, w - 1);      //在后一半求解      quickSort(A, w + 1, high);    } } var A = [5, 6, 4, 7, 3]; quickSort(A, 0, A.length - 1); println(A); //3,4,5,6,7

split算法的思想应用：

设A[1..n]是一个整数集，给出一算法重排数组A中元素，使得所有的负整数放到所有非负整数的左边，你的算法的运行时间应当为Θ(n)

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

function sort1(A) {    var i = 0, j = A.length - 1;    while (i < j) {      if (A[i] >= 0 && A[j] >= 0) {        j--;      }      else if (A[i] < 0 && A[j] < 0) {        i++;      }      else if (A[i] > 0 && A[j] < 0) {        swap(A, i, j);        i++;        j--;      }      else {        i++;        j--;      }    } } function sort2(A) {    if (A.length <= 1) { return ; }    var i = 0;    for ( var j = i + 1; j < A.length; j++) {      if (A[j] < 0 && A[i] >= 0) {        swap(A, i, j);        i++;      }    } } var a = [1, -2, 3, -4, 5, -6, 0]; sort1(a); println(a); //-6,-2,-4,3,5,1,0 var b = [1, -2, 3, -4, 5, -6, 0]; sort2(b); println(b); //-2,-4,-6,1,5,3,0