【剑指Offer】优化时间和空间效率（下）

丑数

题目描述

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

分析

新建一个长度为N的数组res来保存丑数，res[0] = 1。
具体过程如下所示：

flag2，flag3，flag5用来标记下一个放入数组的元素。这样可以比较三个数的大小，保证数组是按照从小到大排列的。

Java代码

public class Solution {
    public int GetUglyNumber_Solution(int index) {
        if(index <= 0)
            return 0;
        int[] res = new int[index];
        int flag2 = 0;
        int flag3 = 0;
        int flag5 = 0;
        res[0] = 1;
        for(int i=1; i<index; i++){
            res[i] = Math.min(res[flag2]*2, 
                              Math.min(res[flag3]*3, res[flag5]*5));
            if(res[flag2]*2 == res[i])
                flag2++;
            if(res[flag3]*3 == res[i])
                flag3++;
            if(res[flag5]*5 == res[i])
                flag5++;
        }
        return res[index-1];
    }
}

---

第一个只出现一次的字符

题目描述

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）。

分析

1. 为了方便读取字符串中的字符，首先将字符串转换成一个字符数组chars。
2. 新建一个HashMap，key为字符，value为出现的次数；
3. 遍历chars，将其保存到HashMap中。若HashMap中的key值没有当前字符，则新增进去，并把value设为1；否则把该key映射的value值加1。
4. 再次遍历chars，发现第一个value=1的key值，返回其下标即可；
5. 若不存在，返回-1。

Java代码

import java.util.HashMap;
public class Solution {
    public int FirstNotRepeatingChar(String str) {
        if(str.length() == 0 || str == null)
            return -1;
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        char[] chars = str.toCharArray();
        for(char c : chars){
            int times = map.getOrDefault(c, 0);
            map.put(c, times+1);
        }
        for(int i=0; i<chars.length; i++){
            if(map.get(chars[i]) == 1)
                return i;
        }
        return -1;
    }
}

---

数组中的逆序对

题目描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007。

分析

例如数组{7,5,6,4}有5个逆序对{7,5}、{7,6}、{7,4}、{5,4}、{6,4}

第(4)步的具体过程如下：

第(3)步也是同样的方法得到cntLeft = 1，cntRight=1。所以一共有cnt+cntLeft+cntRight = 3+1+1= 5个逆序对。

Java代码

public class Solution {
    public int InversePairs(int [] array) {
        if(array.length == 0 || array == null)
            return 0;
        
        int[] arrayCopy = new int[array.length];
        for(int i=0; i<array.length; i++)
            arrayCopy[i] = array[i];
        int res = Inverse(array, arrayCopy, 0, array.length-1);
        return res;
    }
    public int Inverse(int[] array, int[] arrayCopy, int low, int high){
        if(low == high)
            return 0;
        int mid = (low + high) >> 1;
        int cntLeft = Inverse(array, arrayCopy, low, mid) % 1000000007;
        int cntRight = Inverse(array, arrayCopy, mid+1, high) % 1000000007;
        int cnt = 0;
        
        int i = mid;
        int j = high;
        int idxCopy = high;
        while(i>=low && j>mid){
            if(array[i] > array[j]){
                cnt += (j-mid);
                arrayCopy[idxCopy--] = array[i--];
                cnt %= 1000000007;
            }
            else
                arrayCopy[idxCopy--] = array[j--];
        }
        while(i >= low)
            arrayCopy[idxCopy--] = array[i--];
        while(j > mid)
            arrayCopy[idxCopy--] = array[j--];
            
        // 将排序好的子数组arrayCopy代替原数组array中的子数组
        for(int x=low; x<=high; x++)
            array[x] = arrayCopy[x];
        
        return (cnt + cntLeft + cntRight) % 1000000007;
    }
}

---

两个链表的第一个公共结点

题目描述

输入两个链表，找出它们的第一个公共结点。
链表结点定义如下：

public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}

分析

根据结点信息可知，该链表是单项链表。如果两个链表有共同结点则链表呈“Y”型。
情况1：
两条链表有共同的结点，且长度相同，则从前向后遍历一次即可。当p1=p2时的结点即为所求。

情况2：
两条链表有共同的结点，且长度不同，则如下操作。当p1=p2时的结点即为所求。

从这之后，p1和p2就同步了，与情况1类似。

情况3:
两条链表没有共同结点。

总结：
当两条链表长度相同时：

• 没有共同结点：从前到后遍历，p1.next = p2.next=null时结束;
• 有共同结点：从前到后遍历，p1 = p2时的结点即为所求，结束;

当两条链表长度不同时：

• 没有共同结点：从前到后遍历一次结束，第二次遍历直到p1.next = p2.next=null时结束;
• 有共同结点：从前到后遍历一次结束后即可得知两条链表的长度差，第二次遍历时p1和p2同步，p1 = p2时的结点即为所求，结束;

Java代码

public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
        while(p1 != p2){
            p1 = (p1==null) ? pHead2 : p1.next;
            p2 = (p2==null) ? pHead1 : p2.next;
        }
        return p1;
    }
}