1.丑数
问题描述：
把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，但 14 不是，因为它包含质因子 7。 习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。
解题思路：
首先从丑数的定义我们知道，一个丑数的因子只有 2,3,5，那么丑数 p = 2 ^ x * 3 ^ y * 5 ^ z
换句话说一个丑数一定由另一个丑数乘以 2 或者乘以 3 或者乘以 5 得到
那么我们从 1 开始乘以 2,3,5，就得到 2,3,5 三个丑数，在从这三个丑数出发乘以 2,3,5 就得到 4,6,10, 6,9,15, 10,15,25 九个丑数
因为这 9 个数可能会有重复的，所以从这 9 个丑数中拿出最小的数（要比丑数数组中的数大）加入丑数数组
- (1) 丑数数组 [1]
- 乘以 2：2
- 乘以 3：3
- 乘以 5：5
- (2) 丑数数组 [1,2]
- 乘以 2：2 4
- 乘以 3：3 6
- 乘以 5：5 10
- (3) 丑数数组 [1,2,3]
- 乘以 2：2 4 6
- 乘以 3：3 6 9
- 乘以 5：5 10 15
- (4) 丑数数组 [1,2,3,4]
- 乘以 2：2 4 6 8
- 乘以 3：3 6 9 12
- 乘以 5：5 10 15 20
function GetUglyNumber_Solution(index) {
// write code here
if (index === 0) return 0;
var res = [1];
while (res.length < index) {
var n1 = res.map((x) => x * 2).find((x) => x > res[res.length - 1]);
var n2 = res.map((x) => x * 3).find((x) => x > res[res.length - 1]);
var n3 = res.map((x) => x * 5).find((x) => x > res[res.length - 1]);
res.push(Math.min(n1, n2, n3));
}
return res[index - 1];
}
2.第一次只出现一次的字符
问题描述：
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）
解题思路：
遍历字符串的每一个字符，判断 indexOf 和 lastIndexOf 是不是相同
function FirstNotRepeatingChar(str) {
// write code here
for (let i = 0; i < str.length; i++) {
if (str.indexOf(str[i]) === str.lastIndexOf(str[i])) {
return i;
}
}
return -1;
}
3.数组中的逆序对
问题描述：
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数 P。并将 P 对 1000000007 取模的结果输出。 即输出 P%1000000007
输入描述:
题目保证输入的数组中没有的相同的数字
数据范围：
对于%50 的数据,size<=10^4
对于%75 的数据,size<=10^5
对于%100 的数据,size<=2*10^5
输入：1,2,3,4,5,6,7,0
输出：7
归并排序
function InversePairs(data) {
if (!data || data.length < 2) return 0;
let copy = data.slice(),
count = 0;
count = mergeSort(data, copy, 0, data.length - 1);
return count % 1000000007;
}
function mergeSort(data, copy, start, end) {
if (end === start) return 0;
let mid = (end - start) >> 1,
left = mergeSort(copy, data, start, start + mid),
right = mergeSort(copy, data, start + mid + 1, end),
count = 0,
p = start + mid, //前一个数组的最后一个下标
q = end, //后一个数组的下标
copyIndex = end; //辅助数组下标，从最后一个算起
while (p >= start && q >= start + mid + 1) {
if (data[p] > data[q]) {
count += q - start - mid;
copy[copyIndex--] = data[p--];
} else {
copy[copyIndex--] = data[q--];
}
}
while (p >= start) {
copy[copyIndex--] = data[p--];
}
while (q >= start + mid + 1) {
copy[copyIndex--] = data[q--];
}
return left + right + count;
}
4.两个链表的第一个公共结点
问题描述：
输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）
解题思路：
首先我们要知道什么是公共结点，两个链表从某一节点开始，他们的 next 都指向同一个结点。但由于是单向链表的结点，每个结点只有一个 next，因此从第一个公共结点开始，之后他们的所有结点都是重合的，不可能再出现分叉。双指针法。创建两个指针 p1 和 p2,分别指向两个链表的头结点，然后依次往后遍历。如果某个指针到达末尾，则将该指针指向另一个链表的头结点；如果两个指针所指的结点相同，则循环结束，返回当前指针指向的结点。比如两个链表分别为：1->3->4->5->6 和 2->7->8->9->5->6。短链表的指针 p1 会先到达尾部，然后重新指向长链表头部，当长链表的指针 p2 到达尾部时，重新指向短链表头部，此时 p1 在长链表中已经多走了 k 步(k 为两个链表的长度差值)，p1 和 p2 位于同一起跑线，往后遍历找到相同结点即可。其实该方法主要就是用链表循环的方式替代了长链表指针先走 k 步这一步骤。
/*function ListNode(x){
this.val = x;
this.next = null;
}*/
function FindFirstCommonNode(pHead1, pHead2) {
// write code here
var p1 = pHead1;
var p2 = pHead2;
while (p1 !== p2) {
p1 = p1 == null ? pHead2 : p1.next;
p2 = p2 == null ? pHead1 : p2.next;
}
return p1;
}