励志

If you focus on what you left behind, you will never be able to see what lies ahead.
如果老是挂念已失去的，你就永远看不到未来。

题目来源：
https://leetcode-cn.com/leetbook/detail/illustration-of-algorithm/

配合学习文档：
https://www.kancloud.cn/alex_wsc/dataalg/1853982

书籍推荐：

《漫画算法》

视频推荐：
https://www.bilibili.com/video/BV1E4411H73v

目录

一、剑指 Offer 18. 删除链表的节点

题：

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

注意：此题对比原题有改动

示例 1:

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2:

输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明：

题目保证链表中节点的值互不相同
若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点

解：

解题思路：数据结构基础
AC代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if(head.val == val) return head.next; // 判断头结点
        ListNode pre = head, cur = head.next;
        // 定位
        while(cur != null && cur.val != val){
            pre = cur;
            cur = cur.next;
        }
        // 若找到(cur.val == val),删除
        if(cur != null) pre.next = cur.next;
        return head;
    }
}

• 时间复杂度 O(N)： N 为链表长度，删除操作平均需循环 N/2 次，最差 N 次。
• 空间复杂度 O(1) ： cur, pre 占用常数大小额外空间。

二、剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

题：

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

示例：

输入：nums = [1,2,3,4]
输出：[1,3,2,4] 
注：[3,1,2,4] 也是正确的答案之一。

提示：

0 <= nums.length <= 50000
0 <= nums[i] <= 10000

解：

解题思路：双指针交换

==x&1 位运算 等价于 x%2==

AC代码：

class Solution {
    public int[] exchange(int[] nums) {
        int i = 0, j = nums.length-1;
        while(i < j){
            while(i < j && (nums[i] & 1) == 1) i++;
            while(i < j && (nums[j] & 1) == 0) j--;
            int temp = nums[i];
            nums[i] = nums[j];
            nums[j] = temp;
        }
        return nums;
    }
}

• 时间复杂度 O(N) ： N 为数组 nums 长度，双指针 i, j 共同遍历整个数组。
• 空间复杂度 O(1) ： 双指针 i, j 使用常数大小的额外空间。

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

题：

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

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

示例：

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

返回链表 4->5.

解：

解题思路：双指针 + 共同移动
AC代码：

/**
 * 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) {
        ListNode former = head, latter = head;
        // former 先行
        while((k--) > 0){
            if(former == null) return null; // 越界处理
            former = former.next;
        }
        // former，latter同行
        while(former != null){
            former = former.next;
            latter = latter.next;
        }
        return latter;
    }
}

• 时间复杂度 O(N) ： N 为链表长度；总体看， former 走了 N 步， latter 走了 (N-k) 步。
• 空间复杂度 O(1) ： 双指针 former , latter 使用常数大小的额外空间。

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

题：

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

示例1：

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

限制：

0 <= 链表长度 <= 1000

解：

解题思路：链表
AC代码：

/**
 * 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 preHead = new ListNode(0), // 伪头结点
        cur = preHead; // 指针
        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;
        }
        cur.next = l1 != null ? l1 : l2;
        return preHead.next;
    }
}

• 时间复杂度 O(M+N)： M, N 分别为链表 l1,l2 的长度，合并操作需遍历两链表。
• 空间复杂度 O(1)： 节点引用 dum , cur 使用常数大小的额外空间。

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

题：

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

如下面的两个链表：

在节点 c1 开始相交。

示例 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 个节点。

示例 2：

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

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

注意：

• 如果两个链表没有交点，返回 null.
• 在返回结果后，两个链表仍须保持原有的结构。
• 可假定整个链表结构中没有循环。
• 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

解：

解题思路：

走到尽头见不到你，于是走过你来时的路，等到相遇时才发现，你也走过我来时的路。

思想： 1+2 = 2+1

没有交点的情况可以约化为 交点为 None 的情况。（即将两链表末端的 None 看作交点）

AC代码：

/**
 * 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 A = headA, B = headB;
        while(A != B){
            A = A != null ? A.next : headB;
            B = B != null ? B.next : headA;
        }
        return A;
    }
}

• 时间复杂度 O(a + b) ： 最差情况下（即 |a - b| = 1 , c = 0），此时需遍历 a + b 个节点。
• 空间复杂度 O(1) ： 节点指针 A , B 使用常数大小的额外空间。

六、剑指 Offer 57. 和为 s 的两个数字

题：

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]

示例 2：

输入：nums = [10,26,30,31,47,60], target = 40
输出：[10,30] 或者 [30,10]

限制：

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^6

解：

解题思路：双指针
AC代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int i = 0, j = nums.length - 1;
        while(i < j){
            int sum = nums[i] + nums[j];
            if(sum < target) i++;
            else if(sum > target) j--;
            else return new int[]{nums[i],nums[j]};
        }
        return new int[0];
    }
}

• 时间复杂度 O(N) ： N 为数组 nums 的长度；双指针共同线性遍历整个数组。
• 空间复杂度 O(1) ： 变量 i, j 使用常数大小的额外空间。

七、剑指 Offer 58 - I. 翻转单词顺序

题：

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. "，则输出"student. a am I"。

示例 1：

输入: "the sky is blue"
输出: "blue is sky the"

示例 2：

输入: "  hello world!  "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

示例 3：

输入: "a good   example"
输出: "example good a"
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

说明：

无空格字符构成一个单词。
输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

解：

解题思路：双指针
AC代码：

class Solution {
    public String reverseWords(String s) {
        s = s.trim(); // 去除首尾空格
        StringBuilder res = new StringBuilder();
        int i = s.length() - 1, j = i; // 单词的左右边界指针
        while(i >= 0){
            while(i >= 0 && s.charAt(i) != ' ') i--; //单词左边界
            res.append(s.substring(i+1, j+1) + " ");
            while(i >= 0 && s.charAt(i) == ' ') i--; // 单词右边界 
            j = i;
        }
        return res.toString().trim();
    }
}

• 时间复杂度 O(N) ： 其中 N 为字符串 s 的长度，线性遍历字符串。
• 空间复杂度 O(N) ： 新建的 StringBuilder 中的字符串总长度 ≤N ，占用 O(N) 大小的额外空间。