通常情况下，搞金融的都会考算法。
一、排序
说明
时间复杂度指的是一个算法执行所耗费的时间
空间复杂度指运行完一个程序所需内存的大小
稳定指，如果a=b,a在b的前面，排序后a仍然在b的前面
不稳定指，如果a=b，a在b的前面，排序后可能会交换位置
基本排序：冒泡、选择、插入
高级排序：希尔、快速、归并
原生js里面的sort方法，在firefox里面是用归并排序实现的，而在chrome里面是用快速排序的变体来实现的。
image.png
1、冒泡排序：
https://www.jianshu.com/p/b5eaf39c4217
原理
冒泡排序（Bubble Sorting），是一种计算机科学领域的较简单的排序算法。它的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）, 依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。故名“冒泡排序”。
- 平均时间复杂度O(n*n)
- 最好情况O(n)
- 最差情况O(n*n)
- 空间复杂度O(1)
- 稳定性：稳定
优化后的算法
var examplearr = [5, 4, 3, 2, 1];
function sortarr(arr) {
let len = arr.length;
// 外面循环是数组有几个元素，就要循环几次才能排好序，
// 最后一次数组已经拍好序了，所不用循环了所以len-1
for (i = 0; i < len - 1; i++) {
// 每次循环只要交换len-1次(j最大数为len-1,所以j+1最大为len换句话说最后个数，没有其他数可以比较了)
// 每循环一次，就排好一个数字所以后面的数字就不用循环了所以 len - 1 - i
for (j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]//es6s
}
}
}
return arr;
}
sortarr(examplearr);
console.log(examplearr);
//封装
Array.prototype.doubbleSort = function () {
let arr = this, len = this.length;
for (let i = 0; i < len - 1; i++) {
for (let j = 0; j < len - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
}
}
}
return arr
}
let newArr = [5, 4, 3, 2, 1].doubbleSort()
console.log(newArr)
2、选择排序：
https://www.jianshu.com/p/92226136dcd1
原理
首先从原始数组中找到最小的元素，并把该元素放在数组的最前面，然后再从剩下的元素中寻找最小的元素，放在之前最小元素的后面，知道排序完毕。
- 平均时间复杂度O(n*n)
- 最好情况O(n*n)
- 最差情况O(n*n)
- 空间复杂度O(1)
- 稳定性：不稳定
算法
var example=[8,94,15,88,55,76,21,39];
function selectSort(arr){
var len=arr.length;
var minIndex,temp;
console.time('选择排序耗时')；
for(i=0;iminIndex始终保存着最小值的位置的索引，随着i的自增，遍历的数组长度越来越短，直到完成排序。
3、插入排序
https://www.jianshu.com/p/fd789c9c382c
原理
用未参与排序的数与已经排好序的数从后往前做比较,比较中找到自己的位置然后插入到该位置
- 平均时间复杂度O(n*n)
- 最好情况O(n)
- 最差情况O(n*n)
- 空间复杂度O(1)
- 稳定性：稳定
算法
function insertSort(arr) {
var len = arr.length;
for (var i = 1; i < len; i++) {
for (var j = i; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
// 调换两者的位置
[arr[j], arr[j - 1]] = [arr[j - 1], arr[j]]
}
}
}
return arr
}
var arr = [5, 4, 3, 2, 1];
console.log(insertSort(arr))
4、快速排序：
原理
从数组中选定一个基数，然后把数组中的每一项与此基数做比较，小的放入一个新数组，大的放入另外一个新数组。然后再采用这样的方法操作新数组。直到所有子集只剩下一个元素，排序完成。
- 平均时间复杂度O(nlogn)
- 最好情况O(nlogn)
- 最差情况O(n*n)
- 空间复杂度O(logn)
- 稳定性：不稳定
解析
pivotIndex是将数组的长度除2向下取整得到的一个数值，数组的长度是不断减半的，所以最后它的值为0，pivot是利用splice方法从数组里获取一个基数
算法
function fastSort(arr) {
let len = arr.length;
if (len < 2) {
return arr
}
let left = [];
let right = [];
let base = Math.floor(len / 2)
// 把基数3从数组中去掉，此时数组的长度也变成4了
let baseNum = arr.splice(base, 1)[0]
for (i = 0; i < arr.length; i++) {
if (baseNum > arr[i]) {
left.push(arr[i])
} else {
right.push(arr[i])
}
}
// 递归操作后把把切割的数组加进来
return fastSort(left).concat([baseNum], fastSort(right))
}
console.log(fastSort([5, 4, 3, 2, 1]))
5、归并排序
6、希尔排序
https://segmentfault.com/a/1190000009461832
二、堆栈、队列、链表
堆栈：https://juejin.im/entry/58759e79128fe1006b48cdfd
队列：https://juejin.im/entry/58759e79128fe1006b48cdfd
链表：https://juejin.im/entry/58759e79128fe1006b48cdfd
（1）js数组本身就具备堆栈和队列特性。
（2）堆栈：先进后出。
三、递归
递归：https://segmentfault.com/a/1190000009857470
（1）60%的算法题都用到递归。
四、波兰式和逆波兰式
理论：http://www.cnblogs.com/chenying99/p/3675876.html
源码：https://github.com/Tairraos/rpn.js/blob/master/rpn.js