二分查找
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
let arr = [3, 5, 4, 9, 10, 23, 16, 2]
function binary (findVal, arr, minIndex, maxIndex) {
if (minIndex <= maxIndex) {
if (arr[minIndex] === findVal) {
return minIndex
}
if (arr[maxIndex] === findVal) {
return maxIndex
}
let mid = Math.ceil((minIndex + maxIndex) / 2)
if (arr[mid] === findVal) {
return mid
} else if (arr[mid] > findVal) {
return binary(findVal, arr, minIndex, mid - 1)
} else {
return binary(findVal, arr, mid + 1, maxIndex)
}
}
return -1
}
console.log(arr.sort((a, b) => a - b))
console.log(binary(16, arr, 0, arr.length - 1))
冒泡排序
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
原理：
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2、对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3、针对所有的元素重复以上的步骤，除了最后一个。
4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
let a = [6, 1, 2, 7, 9, 3, 4, 5, 10, 8]
function sort (arr) {
let length = arr.length
for (let i = 0; i < length - 1; i++) {
for (let j = 0; j < length - 1 - i; j++) {
if (arr[j] > arr[j+1]) {
let temp = arr[j]
arr[j] = arr[j+1]
arr[j+1] = temp
}
}
}
return arr
}
console.log(sort(a))
快速排序
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
原理：
1、设置两个变量i、j，排序开始的时候：i=0，j=N-1
2、以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3、从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换
4、从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换
5、重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）
let a = [6, 1, 2, 7, 9, 3, 4, 5, 10, 8]
function quickSort(arr,l,r){
if(l < r){
let i = l, j = r, x = arr[i];
while(i<j){
while(i<j && arr[j] > x) j--;
if(i<j) {
//这里用i++，被换过来的必然比x小，赋值后直接让i自加，不用再比较，可以提高效率
arr[i++] = arr[j];
}
while(i<j && arr[i] < x) i++;
if(i<j) {
//这里用j--，被换过来的必然比x大，赋值后直接让j自减，不用再比较，可以提高效率
arr[j--] = arr[i];
}
}
arr[i] = x;
quickSort(arr, l, i-1);
quickSort(arr, i+1, r);
}
return arr
}
console.log(quickSort(a,0, a.length -1))
例子：分别从初始序列“6 1 2 7 9 3 4 5 10 8”两端开始“探测”。此处设置的基准数是最左边的数，这里可以用两个变量i和j，分别指向序列最左边和最右边。
首先基准数是6，先从右边往前开始找，找到5，然后将a[j]赋值给a[i]，得到序列为
5,1,2,7,9,3,4,5,10,8
然后从左边开始查找，找到7，此时将a[i]赋值给a[j]，得到序列为
5,1,2,7,9,3,4,7,10,8
继续右边查找，找到4，将a[j]赋值给a[i]，得到序列为
5,1,2,4,9,3,4,7,10,8
继续左边查找，找到9，将a[i]赋值给a[j]，得到
5,1,2,4,9,3,9,7,10,8
继续右边查找，找到3，将a[j]赋值给a[i]，得到序列为
5,1,2,4,3,3,9,7,10,8
此时，继续往下走得出 i === j，所以将x赋值给a[i],得到
5,1,2,4,3,6,9,7,10,8
到此，第一轮的探测结束了，通过递归，可以得到最终的排序结果。
统计字符串中次数最多字母
利用obj的key来存字母，value存出现的次数
let a = 'asfbdhfsbsddssvre'
function getMaxChar (str) {
let obj = {}
for (let i = 0; i < str.length - 1; i++) {
if (!obj[str[i]]) {
obj[str[i]] = 1
} else {
obj[str[i]] += 1
}
}
let maxVal = ''
let maxChat = ''
for (let k in obj) {
if (obj[k] > maxVal) {
maxVal = obj[k]
maxChat = k
}
}
console.log(maxChat + ':' + maxVal)
}
getMaxChar(a)
