剑指Offer（三）

1、剑指 Offer 63. 股票的最大利润

假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

class Solution {
    public int maxProfit(int[] prices) {
        if (prices.length <= 0) {
            return 0;
        }
        int res = 0, min = prices[0];
        for (int i = 1; i < prices.length; i ++) {
            min = Math.min(min, prices[i]);
            res = Math.max(res, prices[i] - min);
        }
        return res;
    }
}

2、剑指 Offer 42. 连续子数组的最大和

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。

要求时间复杂度为O(n)。

示例1:

输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

class Solution {
    public int maxSubArray(int[] nums) {
        int max = nums[0];
        int former = 0;//用于记录dp[i-1]的值，对于dp[0]而言，其前面的dp[-1]=0
        int cur = nums[0];//用于记录dp[i]的值
        for(int i = 0; i < nums.length; i ++){
            cur = nums[i];
            if(former > 0) {
                cur += former;
            }
            if(cur > max) {
                max = cur;
            }
            former = cur;
        }
        return max;
    }
}

3、剑指 Offer 47. 礼物的最大价值

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

示例 1:

输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 12
解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物

class Solution {
    public int maxValue(int[][] grid) {
       
        int sum = grid[0][0];
        int i = 0, j = 0;
        while (i < grid.length || j < grid[0].length) {
            //比较右边和下边大小，往值大的方向移动
            if (grid[i + 1][j] >= grid[i][j + 1]) {
                sum += grid[i + 1][j];
                i ++;
            } else {
                sum += grid[i][j + 1];
                j ++;
            }
            //到达最底端，如果还可以往右边移动，则移动
            if (i + 1 == grid.length) {
                sum += grid[i][j + 1];
                break;
            } 
            //到达最右端，如果还可以往下端移动，则移动
            if (j + 1 == grid[0].length) {
                sum += grid[i + 1][j];
                break;
            } 
        }
        return sum;
    }
}

4、剑指 Offer 46. 把数字翻译成字符串

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

示例 1:

输入: 12258
输出: 5
解释: 12258有5种不同的翻译，分别是"bccfi", “bwfi”, “bczi”, “mcfi"和"mzi”

class Solution {
    public int translateNum(int num) {
        String s = String.valueOf(num);
        int[] dp = new int[s.length() + 1];
        dp[0] = 1;//无数字
        dp[1] = 1;//只有第一位数字
        for (int i = 2; i <= s.length(); i++) {
            String temp = s.substring(i - 2, i);//取最后两位数
            //最后两位数组成的值在：[10,25]之间
            if (temp.compareTo("10") >= 0 && temp.compareTo("25") <= 0) {
                //dp[i-2]:最后两位数组合算  dp[i-1]:最后两位数单独算
                dp[i] = dp[i - 1] + dp[i - 2];
            } else {
                dp[i] = dp[i - 1];
            }
        }
        return dp[s.length()];
    }
}

5、剑指 Offer 48. 最长不含重复字符的子字符串

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int N = 40000;

        char[] a = new char[s.length()];
        for (int i = 0; i < s.length(); i ++) {
            a[i] = s.charAt(i);
        }

        //记录序列长度
        int res = 0;
        //记录序列中a[i]的值的个数
        char[] b = new char[N];

        //双指针遍历，i是移动指针，j指针用于保证在序列的最左位置，使得[j,i]之间的序列不重复
        for (int i = 0, j = 0; i < s.length(); i ++) {
            b[a[i]] ++;//a[i]的值个数+1
            //序列中出现重复值，j指针后移
            while (b[a[i]] > 1) {
                b[a[j]] --;//删除序列中j最初指向的值
                j ++;//j指针后移
            }

            //res记录序列的最长长度
            res = Math.max(res, i - j + 1);
        }
        return res;
    }
}

6、剑指 Offer 22. 链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        int len = 0;
        ListNode p = head;
        while (p.next != null) {
            p = p.next;
            len ++;
        }

        while ((len - k + 1) > 0 && head.next != null) {
            head = head.next;
            len --;
        }
        return head;
    }
}

7、剑指 Offer 25. 合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode l3 = new ListNode(0), cur = l3;//l3合并后的链表，cur指向当前节点
        //同时遍历l1 l2,cur之前值小的节点
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                cur.next = l1;
                l1 = l1.next;
            } else {
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }
        //退出循环时，l1和l2有一个为空，cur指向另一个
        if (l1 != null) {
            cur.next = l1;
        } else {
            cur.next = l2;
        }
        return l3.next;
    }
}

8、剑指 Offer 52. 两个链表的第一个公共节点

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
      ListNode p1 = headA, p2 = headB;
        while (p1 !=  p2) {
            if (p1 != null) {
                p1 = p1.next;
            } else {
                p1 = headB;
            }
            if (p2 != null) {
                p2 = p2.next;
            } else {
                p2 = headA;
            }
        }
        return p1;  
    }
}