数组字符串操作算法

回文字符串：即字符串从前往后读和从后往前读字符顺序是一致的。
如：字符串abccba，从前往后读是a-b-c-c-b-a；从后往前读也是a-b-c-c-b-a

function palindRome(str){
    var len = str.length;
    var str1 = "";
    for(var i=len-1; i>=0;i--){
        str1+=str[i];
    }
    console.log(str1 == str)
}
palindRome("abcba");//true
palindRome("abcbac");//false

从一个字符串中找出重复次数最多的字符

var str = "fsfssgsgsngmshj";
//1 先将字符串转换成数组
var newArr = str.split("");
//2 创建一个对象
var obj = {};
//3  遍历数组,判断对象中是否存在数组中的值,如果存在值+1,不存在赋值为1
for(var i = 0;i<newArr.length;i++){
    if(obj[newArr[i]]){
        obj[newArr[i]] += 1;
    }else{
        obj[newArr[i]] = 1;
    }
}
//4 定义两个变量存储字符串,字符串出现的字数
var num = 0;
var number = "";
for(var k in obj){
    if(obj[k]>num){
        num = obj[k];
        number = k;
    }
}
console.log("出现次数："+num+"最多的字符:"+number)

和为S的字符串,输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
思路: 双指针。输出乘积最小的就是相距最远的。

function FindNumbersWithSum(array, sum)
{
    // write code here
    if(array.length < 2) return [];
    var left = 0;
    var right = array.length - 1;
    const res = [];
    while(left < right){
        if(array[left] + array[right] < sum){
            left++;
        }else if(array[left] + array[right] > sum){
            right--;
        }else{
            res.push(array[left],array[right]);
            break;
        }
    }
    return res;
}

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回
1.如果一个节点有右子树，那么它的下一个节点就是它的右子树中的最左子节点。也就是说，从右子节点出发一直沿着指向左子节点的指针，我们就能找到下一个节点
2.如果没有右子树，又可以分为两种情况
如果节点是它父节点的左子节点，那么它的下一个节点就是它的父节点。
如果一个节点既没有右子树，并且它还是父节点的右子节点，那么需要沿着指向父节点的指针一直向上便利，直到找到一个是它父节点的左子节点的节点。

function GetNext(pNode){
    if(pNode==null) return null;
    if(pNode.right!==null){
        // 第一种
        pNode=pNode.right
        while(pNode.left!==null){
              pNode=pNode.left
        }
        return pNode;
    }
     while (pNode.next !== null) {
        // 第2种
        if (pNode === pNode.next.left) {
        return pNode.next;
        }
        pNode = pNode.next;
    }
    return null;
}

对称的二叉树
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

    function isSymmetrical(pRoot) {
        // write code here
        if (pRoot == null) return true
        return compareRoot(pRoot.left, pRoot.right)

    

}
    function compareRoot(left, right) {
        if (left == null) return right === null
        if (right == null) return false
        if (left.val !== right.val) return false
        return compareRoot(left.left, right.right) && compareRoot(left.right, right.left)

    }

版本号排序;
在排序的过程中，分为两层，外层的核心是利用选择排序，选择排序过程中进行数值比较时，比较的成员仍然是两个数组：

// 使用的是选择排序
const versionSort = version => {
  const temp = version.map(v => v.split('.'));
  for (let i = 0; i < temp.length; i++) {
    let minIndex = i;
    for (let j = i; j < temp.length; j++) {
      for (let k = 0; k < temp[j].length; k++) {
        const current = +temp[j][k],
        min = +temp[minIndex][k];
        if (current < min) {
          minIndex = j;
        }
        // 只要不等，就立刻结束最内层遍历！
        if (current !== min) {
          break
        }
      }
    }
    [temp[i], temp[minIndex]] = [temp[minIndex], temp[i]];
  }
  return temp.map(v = > v.join('.'))
};

const version1 = ['1.45.0', '1.5', '6', '3.3.3.3.3'];
console.log(versionSort(version1));
// ["1.5", "1.45.0", "3.3.3.3.3", "6"]

const version2 = ['0.1.1', '2.3.3', '0.3002.1', '4.2', '4.3.5', '4.3.4.5'];
console.log(versionSort(version2));
// ["0.1.1", "0.3002.1", "2.3.3", "4.2", "4.3.4.5", "4.3.5"]

数组扁平化
[1, [2, 3, [4, 5]]] ------> [1, 2, 3, 4, 5]

// 1、 递归
    function fn(arr) {
        let res = []
        arr.forEach(element => {
            if (Array.isArray(element)) {
                let child = fn(element)
                res = res.concat(child)
            } else {
                res.push(element)
            }
        });
        return res
    }
    fn([1, [2, 3, [4, 5]]])

js实现千位分隔符

function numFormat(num){
    num=num.toString().split(".");  // 分隔小数点
    var arr=num[0].split("").reverse();  // 转换成字符数组并且倒序排列
    var res=[];
    for(var i=0,len=arr.length;i<len;i++){
      if(i%3===0&&i!==0){
         res.push(",");   // 添加分隔符
      }
      res.push(arr[i]);
    }
    res.reverse(); // 再次倒序成为正确的顺序
    if(num[1]){  // 如果有小数的话添加小数部分
      res=res.join("").concat("."+num[1]);
    }else{
      res=res.join("");
    }
    return res;
}

var a=1234567894532;
var b=673439.4542;
console.log(numFormat(a)); // "1,234,567,894,532"
console.log(numFormat(b)); // "673,439.4542"

js合并区间;输入: [[1,3],[2,6],[8,10],[15,18]] 输出: [[1,6],[8,10],[15,18]] 解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6]

    let arr = [[1, 3], [2, 6], [8, 10], [15, 18]]
    const unite = function () {
        for (let i = 0; i < arr.length - 1; i++) {
            if (arr[i][0] <= arr[i + 1][0] && arr[i + 1][0] <= arr[i][1]) {
                arr[i] = [arr[i][0], Math.max(arr[i + 1][1], arr[i][1])]
                arr.splice(i + 1, 1)
            }
        }
        return arr
    }
    console.log(unite(arr));

下划线转换驼峰相互间转换

        // 下划线转换驼峰
        function toHump(name) {
            return name.replace(/\_(\w)/g, function (metch) {
                return metch.substr(1).toUpperCase()
            })
        }
        console.log(toHump('adf_d'));

        // 驼峰转换下划线
        function toLine(name) {
            return name.replace(/([A-Z])/g, function (metch) {
                return '_' + metch.toLowerCase()
            });
        }
        console.log(toLine('aBdaNf'));