反转字符串
(leetcode 334)
问题描述： 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
function reverseStr(str){
for(let i=0,len=str.length,j=len-1;i<j;i++,j--){
[str[i],str[j]]=[str[j],str[i]]
}
return str;
}
罗马数字转整数
（leetcode 13）
问题描述： 罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000 例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。 X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。 给定一个罗马数字，将其转换成整数。
思路： 根据规律可以看出，通常情况下，下一位都比上一位要小，都是叠加。特殊情况是前一位比下一位小，前一位是要被减掉，因此我们只需要对比本位跟下一位的关系，就可以知道本位是该减还是该加。
function lmToInt(s){
//建立对应关系 取数
const mapValue=new Map();
mapValue.set("I",1);
mapValue.set("V",5);
mapValue.set("X",10);
mapValue.set("L",50);
mapValue.set("C",100);
mapValue.set("D",500);
mapValue.set("M",1000);
let count=0;
for(let i=0,len=s.length;i<s.length;i++){
if(i<len-1&&mapValue.get(s[i])<mapValue.get(s[i+1])){//前一位小，减去
count-=mapValue.get(s[i])
}else{//默认加上该属性对应的整数值
count+=mapValue.get(s[i])
}
}
return count
}
搜索插入位置
(leetcode 35)
问题描述： 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
思路： 要用负责复杂度为O(log n)那么就优先想到二分法。
/**
* @param {number[]} nums
* @param {number} target
* @return {number}
*/
var searchInsert = function(nums, target) {
let left=0;
let right=nums.length-1;
let pos=nums.length;
while(left<=right){
let mid=Math.floor(right-left)+left;
if(target<=nums[mid]){
pos=mid;
right=mid-1
}else{
left=mid+1
}
}
return pos
};
判断是否是平衡二叉树
问题描述： 给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
思路： 采用递归的方式，从子节点往上看。
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {boolean}
*/
var isBalanced = function(root) {
return height(root)>=0
};
var height=function(root){
if(root==null){
return 0;
}else{
let leftHeight=height(root.left);
let rightHeight=height(root.right)
if(leftHeight==-1||rightHeight==-1||Math.abs(leftHeight-rightHeight)>1){//子树或者该点两颗子树相差超过1，说明不是平衡二叉树
return -1
}else{
return Math.max(leftHeight,rightHeight)+1
}
}
}
求平衡二叉树深度
思路： 采用递归的方式，求左右子树中最长的，返回给当前父节点
/**
* Definition for a binary tree node.
* function TreeNode(val) {
* this.val = val;
* this.left = this.right = null;
* }
*/
/**
* @param {TreeNode} root
* @return {number}
*/
var maxDepth = function(root) {
return getLength(root)
};
var getLength=function(root){
if(root==null){
return 0
}else{
let llength=getLength(root.left);
let rlength=getLength(root.right);
return Math.max(llength,rlength)+1
}
}
