二分查找

二分查找

二分查找针对有序序列，升序或降序。相比线性查找，二分查找使用分治思想，利用了序列有序的信息，减少了搜索的复杂度。

代码

  1. /** 
  2.  * 二分查找 
  3.  * 假设数组是升序排序 
  4.  */  
  5. function search(arr, item, left, right) {  
  7.     if (left > right) {  
  8.         return -1;  
  9.     }  
  10.     var mid = Math.floor((left + right) / 2);  
  11.     if (arr[mid] === item) {  
  12.         return mid;  
  13.     }  
  14.     else {  
  15.         if (arr[mid] > item) {  
  16.             return search(arr, item, left, mid - 1);  
  17.         }  
  18.         else {  
  19.             return search(arr, item, mid + 1, right);  
  20.         }  
  21.     }  
  22. }  
  24. function bSearch(arr, item) {  
  25.     return search(arr, item, 0, arr.length - 1);  
  26. }

快排

背景

快速排序利用分治的思想，递归地将待排序序列分隔成两部分。快速排序的平均时间复杂度是O(n log n)，这个复杂度是基于比较的排序方法的极限。快速排序的具体实现需要注意一些细节。下面介绍一下具体实现

说明

我们假设是升序排序。快速排序使用了双指针的思想，其基本思想是首先选取一个分隔数，然后两个游标从两侧对向移动，左边游标向右游走，直到遇到大于分隔数的元素停止，右边游标则是向左游走，直到遇到小于等于分隔数的元素则停止，然后交换两个游标指向的元素，然后继续游走。这样操作保证了游走结束时，左边的元素都小于等于分隔数，右边的元素都大于分隔数。这样就完成了一次分隔。然后递归地把分隔点左边的序列和右边的序列进行分隔。最终可以得到升序序列。

实际上两个游标也可以同向出发游走。游走过程中，靠左的游标记为i，靠右的游标记为j，i以左的元素小于等于分隔数，i和j之间的元素大于分隔数，就以右的元素情况未知，等待游走的游标去探索。本文仅介绍对向游走游标的快速排序方法。

根据分隔数选择的不同，快速排序可以分为选择最左的元素作为分隔数和随机选择分隔数两种。随机可以增加算法的适应性。如果用最左的元素作为分隔数，则快排对正序和倒序序列排序性能较差。

代码

选择最左元素为分隔数的快排：

快排过程为：首先选择最左元素作为分隔数，然后让游标对向游走，对序列进行分隔，游标碰撞之后，把最左元素和碰撞点元素交换，使得整个序列被分隔为以分隔数为分界点的两个序列，然后递归地分隔这两个序列。

  1. /** 
  2.  * 快排1 
  3.  */  
  4. function partition(arr, left, right) {  
  5.     var temp;  
  6.     var i = left, j = right;  
  7.     var pivot = arr[left];  
  8.     var result;  
  9.     while (i < j) {  
  10.         // i <= j而不是i < j这样才可以保证i-1位置上的元素满足arr[i] <= pivot  
  11.         // 且是从左至右最后一个满足这个条件的元素  
  12.         while (arr[i] <= pivot && i <= j) {  
  13.             i++;  
  14.         }  
  15.         while (arr[j] > pivot && j >= i) {  
  16.             j--;  
  17.         }  
  18.         if (i < j) {  
  19.             temp = arr[i];  
  20.             arr[i] = arr[j];  
  21.             arr[j] = temp;  
  22.         }  
  23.     }  
  25.     result = i - 1;  
  27.     // 将分隔数移到分隔点  
  28.     if (result !== left) {  
  29.         temp = arr[left];  
  30.         arr[left] = arr[result];  
  31.         arr[result] = temp;  
  32.     }  
  33.     return result;  
  34. }  
  36. function quickSort(arr, left, right) {  
  37.     if (left >= right) {  
  38.         return;  
  39.     }  
  40.     var flag = partition(arr, left, right);  
  41.     quickSort(arr, left, flag - 1);  
  42.     quickSort(arr, flag + 1, right);  
  43. }

随机选择分隔数的快排：
快排过程为：和选择最左元素为分隔数类似，只是需要记录分隔元素的index，以便最后作交换。

  1. /** 
  2.  * 快排 
  3.  */  
  4. function getPivotIndex(left, right) {  
  5.     return Math.round(Math.random() * (right - left)) + left;  
  6. }  
  8. function partition(arr, left, right) {  
  9.     var temp;  
  10.     var i = left, j = right;  
  11.     var pivotIndex = getPivotIndex(left, right);  
  12.     var pivot = arr[pivotIndex];  
  13.     var result;  
  14.     while (i < j) {  
  15.         // i <= j而不是i < j这样才可以保证i-1位置上的元素满足arr[i] <= pivot  
  16.         while (arr[i] <= pivot && i <= j) {  
  17.             i++;  
  18.         }  
  19.         while (arr[j] > pivot && j >= i) {  
  20.             j--;  
  21.         }  
  22.         if (i < j) {  
  23.             temp = arr[i];  
  24.             arr[i] = arr[j];  
  25.             arr[j] = temp;  
  26.             if (i === pivotIndex) {  
  27.                 pivotIndex = j;  
  28.             }  
  29.             if (j === pivotIndex) {  
  30.                 pivotIndex = i;  
  31.             }  
  32.         }  
  33.     }  
  35.     result = i - 1;  
  37.     if (result !== pivotIndex) {  
  38.         temp = arr[result];  
  39.         arr[result] = arr[pivotIndex];  
  40.         arr[pivotIndex] = temp;  
  41.     }  
  43.     return result;  
  44. }  
  46. function quickSort(arr, left, right) {  
  47.     if (left >= right) {  
  48.         return;  
  49.     }  
  50.     var flag = partition(arr, left, right);  
  51.     quickSort(arr, left, flag - 1);  
  52.     quickSort(arr, flag + 1, right);  
  53. }

字符串全排列

题目

给定一个数组，其中元素都是字符串，求出这个数组中所有字符串全排列拼接结果

代码

  1. /*
  2.  * 返回数组中的字符串的全排列
  3.  */
  4. function full(arr, prefix, result) {
  5.     if (arr.length == 1) {
  6.         result.push(prefix + arr[0]);
  7.         return;
  8.     }
  9.     arr.forEach(function (item, index) {
  10.         var temp = arr.slice(0);
  11.         temp.splice(index, 1);
  12.         full(temp, prefix + item, result);
  13.     });
  14. }
  16. var arr = ['1', '2', '3'];
  17. var result = [];
  19. full(arr, '', result);