常见算法

1、二分查找

　　* 在有序数组中查找某个数值，返回数值在数组中的索引

　　　　* 从有序数组的中间开始查找，如果正好是需要查找的数值，则搜索结束，返回索引

　　　　* 如果指定查找的元素大于或者小于中间的元素，那么在大于或者小于中间元素的那一部分进行寻找，然后重复第一部的操作

　　　　* 重复以上过程，直到找到指定元素，找到的话返回索引；查找数组为空时查找失败

　　* 优点是比较次数少，查找速度快；缺点为待查表必须为有序数组，不适用于经常变动并且查找频繁的有序列表

　　* 实现方法分为递归方法与非递归方法

　　　　* 递归方法

function search(arr, key, start, end){
if(start > end){
return -1;
}
var end = end === undefined ? arr.length - 1 : end;
var start = start || 0;
var mid = parseInt((start+end)/2);
if(key == arr[mid]){
return mid;
}else if(key < arr[mid]){
return search(arr, key, start, mid - 1)
}else{
return search(arr, key, mid+1, end)
}
}

　　　　* 非递归方法

function search(arr, key){
var start = 0,
end = arr.length - 1;
while(start <= end){
var mid = parseInt((start+end)/2);
if(key == arr[mid]){
return mid
}else if(key < arr[mid]){
end = mid - 1
}else{
start = mid + 1
}
};
return -1;
}

2、二叉树

　　* 用来模拟具有树状结构性质的数据集合

　　* 树的每一个节点都包含当前节点的值以及所有子节点的列表；二叉树是每个节点最多具有两个子树的树结构

　　* 二叉树的遍历分为三种 - 根据根节点的遍历顺序来区分：

　　　　* 前序遍历 - 根节点 -> 左子树 -> 右子树

　　　　　　* 递归实现

function preorderTraversal(root){
let res = [];
test(root, res);
return res;
}
function test(node, res){
if(!node) return;
res.push(node.val);
test(node.left, res);
test(node.right, res);
}

　　　　　　* 迭代实现

function preorderTraversal(root){
const list = [];
const stack = [];
if(root) stack.push(root)
while(stack.length > 0) {
const curNode = stack.pop()
// 第一步的时候，先访问的是根节点
list.push(curNode.val)
// 我们先打印左子树，然后右子树
// 所以先加入栈的是右子树，然后左子树
if(curNode.right !== null) {
stack.push(curNode.right)
}
if(curNode.left !== null) {
stack.push(curNode.left)
}
}
return list
}

　　　　* 中序遍历 - 左子树 -> 根节点 -> 右子树

　　　　　　* 递归实现

function inorderTraversal(root){
let res = [];
test(root, res);
return res;
}
function test(node, res){
if(!node) return;
test(node.left, res);
res.push(node.val);
test(node.right, res);
}

　　　　* 后序遍历 - 左子树 -> 右子树 -> 根节点

　　　　　　* 递归实现

function inorderTraversal(root){
let res = [];
test(root, res);
return res;
}
function test(node, res){
if(!node) return;
test(node.left, res);
test(node.right, res);
res.push(node.val);
}

　　　　* 层序遍历

　　　　* 广度优先

　　　　* 深度优先

3、数组的中心索引

　　* 数组某元素左侧的元素之和等于右侧元素之和

　　* 解题思路 - 计算数组的元素总和，遍历数组，用总和减去遍历元素之和与当前元素，如果剩余数值与相加之和相等，则该元素为中心索引

　　　　* 题解

function test(nums){
let all = nums.reduce((a,b) => a+b);
let res = -1;
let sd = 0;
for(let i = 0; i < nums.length;i++){
let jk = all - sd - nums[i]
if(sd == jk){
res = i;
break
}
sd+=nums[i]
}
return res;
}