1. js实现大整数相加
思路：就是我们算加法的思想，从后往前，逢十进一。如果不先reverse在循环里倒着加其实也是一样的，但是我觉得这么写更浅显易懂，但可能优化方面就不是很好，因为拿长数字做了基准。
var num1 = 999999999564569;
var num2 = 666666666;
function plus(num1, num2){
var a = num1+'';
var aa = a.split('').reverse(); //用split拆要是字符串才可以
var b = num2+'';
var bb = b.split('').reverse();
var maxLength = Math.max(aa.length, bb.length); //以长串为基准
var sum = 0; //每次的合
var sumFlag = 0; //是否要进位
var arr = []; //新数组，来存加了之后的数字
for(var i = 0; i< maxLength; i++){ //补齐短的数字，因为以长的为基准
//短的是undefined的话parseInt出来是NaN
if(aa[i] == undefined){
aa[i] = 0;
}
if(bb[i] == undefined){
bb[i] = 0;
}
}
for(var i = 0; i< maxLength; i++){
sum = parseInt(aa[i]) + parseInt(bb[i]) + parseInt(sumFlag);
//每一位是两个数字及进位相加
arr[i] = sum;
sumFlag = 0;
if(sum > 9){ //如果需要进位
arr[i] = sum - 10;
sumFlag = 1;
}
if(arr[maxLength-1] == 0 && sumFlag ==1){
//要考虑到一直加为10进行下去的话最后一次取了0没有给前面补1，就会很多位是0，导致后面取0取消掉
arr.push(1);
}
}
return arr.reverse().join('').replace(/^0+/g,''); //翻转过来返回
}
var sum = plus(num1,num2);
console.log(sum);2.尾递归（尾调用）
尾调用：函数执行的过程中，如果最后是一个函数的调用，即这个调用的返回值被当前函数直接返回。
为什么使用尾调用：在递归过程中，一直在调用栈上增加新的堆栈，但其实没有必要，我们可以直接更新调用栈来使用，性能更优化。
例子：
function f(x){
return g(x);
}以下形式不为尾调用：
function f(x){
let y = g(x);
return y;
}
//或者
function f(x){
return g(x) + 1;
}通过尾调用去优化斐波那契数列和阶乘：
//尾递归斐波那契数列，传入第几位，结果是这一位的值
//数列为1，1，2，3，5，8······
function f(n, a = 0, b = 1){
if(n < 1){
return a;
}
return f(n-1, b, a+b);
}
console.log(f(6));
//尾递归阶乘，传入值，返回结果是阶乘后的值
function p(n, all = 1){
if(n == 1){
return all;
}
return p(n - 1, n*all);
}
console.log(p(5));3.排序算法
- 冒泡，时间复杂度o(n²)，稳定
var array = new Array('2','1','4','7','4','8','3','6','4','7');
var tag; //优化，如果上次没有交换就停止冒泡
var tem;
for(var i = 0 ;i < array.length-1 ;i++){
tag = true;
for(var j = 0 ;j < array.length-1-i ;j++){
if(array[j] > array[j+1]){
tem = array[j];
array[j] = array[j+1];
array[j+1] = tem;
tag = false;
}
}
if(tag){
break;
}
}- 快排，时间复杂度最差（完全有序）o(n²)，最小o(n*log2n)，不稳定
var arrBefore = [3,2,4,8,4,7,6,9];
function sort(arr){
if(arr.length <=1){
return arr;
}
var middle = Math.floor(arr.length/2);
var left = [];
var right = [];
var center = arr.splice(middle,1)[0];
for(var i =0;i < arr.length; i++){
if(arr[i] >= center){
right.push(arr[i]);
}else{
left.push(arr[i]);
}
}
return sort(left) .concat(center,sort(right))
}
var arrNew = sort(arrBefore);
console.log(String(arrNew));- 插入，默认第一位已经排好序，将无序区间的元素插入有序区间正确的位置，时间复杂度o(n²)，稳定
var arrBefore = [3,2,5,8,4,7,6,9];
function sort(arr){
for(var i = 1; i<arr.length; i++){
var t = arr[i];
var p = i-1;
while(arr[p] > t && p >= 0){
arr[p+1] = arr[p]
p--;
}
arr[p+1] = t;
}
return arr;
}
var arrNew = sort(arrBefore);
console.log(arrNew);- 选择，从未排序区间中选择最小的放入已排序区间的最后一个，时间复杂度o(n²)，不稳定
var arrBefore = [3,2,5,8,4,7,6,9];
function choose(arr){
let min = 0;
let temp = 0;
for(let i = 0; i < arr.length-1; i++){
min = i;
for(let j = i+1; j< arr.length; j++){
if(arr[j] < arr[min]){
min = j;
}
}
temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
return arr;
}
let result = choose(arrBefore);
console.log(result);