26.
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

function Convert(pRootOfTree) {
    if (!pRootOfTree) {
        return null;
    }
    var lastNode = null;
    lastNode = ConvertNode(pRootOfTree);
    var head = lastNode;
    while (head && head.left) {
        head = head.left;
    }
    return head;
    function ConvertNode(node) {
        if (!node) {
            return;
        }
        if (node.left) {
            lastNode = ConvertNode(node.left);
        }
        node.left = lastNode;
        if (lastNode) {
            lastNode.right = node;
        }
        lastNode = node;
        if (node.right) {
            lastNode = ConvertNode(node.right);
        }
        return lastNode;
    }
}

27.
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

function MoreThanHalfNum_Solution(numbers) {
    if (!numbers || numbers.length === 0) {
        return 0;
    }
    var arr = [];
    var len = numbers.length, index;
    for (var i = 0; i < len; i++) {
        var index = numbers[i];
        arr[index] !== undefined ? arr[index]++ : arr[index] = 1;
    }
    var index = -1;
    var arrLen = arr.length;
    var max = -Infinity;
    for (var i = 0; i < arrLen; i++) {
        if (!arr[i]) continue;
        max = arr[i] > max ? (index = i, arr[i]) : max;
    }
    return max > len / 2 ? index : 0;
}

28.
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

function GetLeastNumbers_Solution(input, k) {
    if (!input || input.length < k) {
        return [];
    }
    return input.sort(function(a, b) {
        return a - b;
    }).slice(0, k);
}

29.
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)

function FindGreatestSumOfSubArray(array) {
    if (array.length < 0) return 0;
    var sum = array[0],
        tempsum = array[0];
    for (var i = 1; i < array.length; i++) {
        tempsum = tempsum < 0 ? array[i] : tempsum + array[i];
        sum = tempsum > sum ? tempsum : sum;
    }
    return sum;
}

30.
求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数。

function NumberOf1Between1AndN(n) {
    if (n < 0) return 0;
    var ones = 0;
    var arr = [];
    while (n) {
        arr.push(n);
        n--;
    }
    return arr.join('').replace(/[^1]+/g, '').length;
}

31.
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

function PrintMinNumber(numbers) {
    if (!numbers || numbers.length === 0) {
        return [];
    }
    var result = [];
    var temp = '';
    ordering(numbers);
    result = result.map(Number).reduce(function(min, a) {
        return min < a ? min : a;
    }, Infinity);
    return result;

    function ordering(tempArr) {
        var innerLen = 0;
        if (tempArr.length === 0) {
            result.push(temp);
            return;
        }
        for (var i = 0; i < tempArr.length; i++) {
            innerLen = tempArr[i].toString().length;
            temp += tempArr[i];
            insideArr = tempArr.concat();
            insideArr.splice(i, 1);
            ordering(insideArr);
            temp = temp.substring(0, temp.length - innerLen);
        }
    }
}

32.
把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

function GetUglyNumber(index) {
    if (index === 0) return 0;
    var uglyNum = [1];
    var factor2 = 0, factor3 = 0, factor5 = 0;
    for (var i = 1; i < index; i++) {
        uglyNum[i] = Math.min(uglyNum[factor2] * 2, uglyNum[factor3] * 3, uglyNum[factor5] * 5);
        if (uglyNum[i] === uglyNum[factor2] * 2) factor2++;
        if (uglyNum[i] === uglyNum[factor3] * 3) factor3++;
        if (uglyNum[i] === uglyNum[factor5] * 5) factor5++;
    }
    return uglyNum[index - 1];
}

33.
在一个字符串(1<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置

function FirstNotRepeatingChar(str) {
    if (!str || !str.length) {
        return -1;
    }
    var hash = {};
    var tempArr = str.split('');
    var unique = [];
    var len = str.length, temp;
    for (var i = 0; i < len; i++) {
        temp = tempArr[i];
        if (hash[temp]) {
            hash[temp].push(i);
        } else {
            hash[temp] = [i];
        }
    }
    for (var key in hash) {
        if (hash.hasOwnProperty(key)) {
            if (hash[key].length === 1) {
                unique.push(hash[key].pop());
            }
        }
    }
    return Math.min.apply(null, unique);
}

35.
输入两个链表，找出它们的第一个公共结点。

function FindFirstCommonNode(pHead1, pHead2) {
    if (!pHead1 || !pHead2) {
        return null;
    }
    var len1 = getLength(pHead1);
    var len2 = getLength(pHead2);
    var lenDiff = len1 - len2;
    var curr1 = pHead1;
    var curr2 = pHead2;
    if (len2 > len1) {
        curr1 = pHead2;
        curr2 = pHead1;
        lenDiff = len2 - len1;
    }
    for (var i = 0; i < lenDiff; ++i)
        curr1 = curr1.next;
    while (curr1 && curr2 && curr1 != curr2) {
        curr1 = curr1.next;
        curr2 = curr2.next;
    }
    return curr1;

    function getLength(node) {
        var len = 0;
        curr = node;
        while (curr) {
            len++;
            curr = curr.next;
        }
        return len;
    }
}

36.
统计一个数字在排序数组中出现的次数。

function GetNumberofK(data, k) {
    return data.reduce(function(count, a) {
        return a === k ? count+1 : count;
    }, 0);
}

37.
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

function TreeDepth(pRoot) {
    if (!pRoot) {
        return 0;
    }
    var depth = 0;
    var currDepth = 0;
    dfs(pRoot);
    return depth;

    function dfs(node) {
        if (!node) {
            depth = depth > currDepth ? depth : currDepth;
            return;
        }
        currDepth++;
        dfs(node.left);
        dfs(node.right);
        currDepth--;
    }
}

38.
输入一棵二叉树，判断该二叉树是否是平衡二叉树。

function IsBalanced(pRoot) {
    if (!pRoot) {
        return true;
    }
    var left = TreeDepth(pRoot.left);
    var right = TreeDepth(pRoot.right);
    var diff = left - right;
    if (diff > 1 || diff < -1)
        return false;
    return IsBalanced(pRoot.left) && IsBalanced(pRoot.right);

    function TreeDepth(pRoot) {
        if (!pRoot) {
            return 0;
        }
        var depth = 0;
        var currDepth = 0;
        dfs(pRoot);
        return depth;

        function dfs(node) {
            if (!node) {
                depth = depth > currDepth ? depth : currDepth;
                return;
            }
            currDepth++;
            dfs(node.left);
            dfs(node.right);
            currDepth--;
        }
    }
}

39.
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

function FindNumsAppearOnce(array) {
    if (!array || array.length < 2)
        return [];
    return array.sort().join(',').replace(/(\d+),\1/g, "").replace(/,+/g, ',').replace(/^,|,$/,'').split(',').map(Number);
}

40.
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

function FindContinuousSequence(sum) {
    if (sum < 3) {
        return [];
    }
    var small = 1, big = 2;
    var mid = (1 + sum) / 2;
    var curr = small + big;
    var result = [];
    while (small < mid) {
        if (curr === sum) {
            pushSeq(small, big);
        }
        while (curr > sum && small < mid) {
            curr -= small;
            small++;
            if (curr === sum) {
                pushSeq(small, big);
            }
        }
        big++;
        curr += big;
    }
    result.sort(function(a, b) {return a[0] - b[0];});
    return result;

    function pushSeq(small, big) {
        var temp = [];
        for (var i = small; i <= big; i++) {
            temp.push(i);
        }
        result.push(temp);
    }
}

41.
输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

function FindNumbersWith(array, sum) {
    if (!array || !array.length) {
        return [];
    }
    var result = [];
    var product = [];
    var head = 0, tail = array.length - 1;
    while (head < tail) {
        var curr = array[head] + array[tail];
        if (curr === sum) {
            result.push([array[head], array[tail]]);
            product.push(array[head] * array[tail]);
            tail--;
            head++;
        } else if (curr > sum) {
            tail--;
        } else {
            head++;
        }
    }
    if (result.length === 0) {
        return [];
    }
    var min = Math.min.apply(null, product);
    var index = product.indexOf(min);
    return result[index];
}

42.
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

function LeftRotateString(str, n) {
    if (!str) {
        return "";
    }
    var len = str.length;
    n = n % len;
    var left = str.slice(0, n);
    var right = str.slice(n);
    return right + left;
}

43.
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

function ReverseSentence(str) {
    return str.split(' ').reverse().join(' ');
}

44.
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…..LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何。为了方便起见,你可以认为大小王是0。

function IsContinuous(numbers) {
    if (!numbers || numbers.length < 1) {
        return false;
    }
    var len = numbers.length;
    numbers.sort(function(a, b) {return a - b;});
    var zeros = 0, gaps = 0;
    for (var i = 0; i < len && numbers[i] == 0; i++) {
        zeros++;
    }
    var small = zeros, big = small + 1;
    while (big < len) {
        if (numbers[small] == numbers[big]) {
            return false;
        }
        gaps += numbers[big] - numbers[small] - 1;
        small = big++;
    }
    return gaps <= zeros;
}

45.
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数….这样下去….直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

function LastRemaining(n, m) {
    if (n < 1 || m < 1) {
        return -1;
    }
    var last = 0;
    for (var i = 2; i <= n; i++) {
        last = (last + m) % i;
    }
    return last;
}

46.
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

function Sum(n) {
    var sum = 0;
    plus(n);
    return sum;

    function plus(num) {
        sum += num;
        num > 0 && plus(--num);
    }
}

47.
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

function Add(num1, num2) {
    var sum, carry;
    do {
        sum = num1 ^ num2;
        carry = (num1 & num2) << 1;
        num1 = sum;
        num2 = carry;
    } while (num2 != 0);
    return num1;
}

48.
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

function duplicate(numbers, duplication) {
    if (!numbers || !numbers.length) {
        return false;
    }
    var len = numbers.length;
    for (var i = 0; i < len; i++) {
        var curr = numbers[i];
        if (numbers.indexOf(curr) !== i) {
            duplication[0] = curr;
            return true;
        }
    }
    return false;
}

49.
给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…A[i-1]A[i+1]…A[n-1]。不能使用除法。

function multiply(array) {
    if (!array || !array.length) {
        return [];
    }
    var result = [];
    var len1 = array.length;
    result[0] = 1;
    for (var i = 1; i < len1; i++) {
        result[i] = array[i - 1] * result[i - 1];
    }
    var temp = 1;
    for (var i = len1 - 2; i >= 0; --i) {
        temp *= array[i + 1];
        result[i] *= temp;
    }
    return result;
}

50.
请实现一个函数用来匹配包括’.’和’’的正则表达式。模式中的字符’.’表示任意一个字符，而’’表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串”aaa”与模式”a.a”和”abaca”匹配，但是与”aa.a”和”ab*a”均不匹配

function match(s, pattern) {
    if (s === "" && pattern === "") {
        return true;
    }
    if (!pattern || pattern.length === 0) {
        return false;
    }
    var reg = new RegExp('^' + pattern + '$');
    return reg.test(s);
}