力扣刷题记录（一）：链表

双指针问题

两个链条求交点，每一条链条到达尾端的时候，执行一次链条的切换，可以最终使两个链条达到同步运行的效果。这里注意到达尾部的条件是为null，而不是下一个结点为null

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    ListNode pointA = headA, pointB = headB;
    while (pointA != pointB) {
        // 到达尾部的时候才需要进行切换链条
        pointA = (pointA == null) ? headB : pointA.next;
        pointB = (pointB == null) ? headA : pointB.next;
    }
    return pointA;
}

反转链表

总结：需要替换什么的时候，一定要给这个结点做好备份

public ListNode reverseList(ListNode head) {
	ListNode cur = head, prev = null;
    while(cur != null){
        // 将下一个结点做一个备份
        ListNode temp = cur.next;
        cur.next = prev;
        prev = cur;
        // 切换到下一个结点
        cur = temp;
    }
    return prev;
}

有序链表的归并

采用一个优先队列进行存储；注意不能直接使用优先队列的toArray方法，而需要依次执行出入队来获取元素。

同时哦注意对于输入链表本身的判空。还需要注意对最后一个链表的尾部置位null

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    if(l1 == null && l2 == null) return null;

    PriorityQueue<ListNode> queue = new PriorityQueue<>((o1, o2) -> o1.val - o2.val);

    while (l1 != null) {
        queue.offer(l1);
        l1 = l1.next;
    }

    while (l2 != null) {
        queue.offer(l2);
        l2 = l2.next;
    }

    ListNode[] nodes = new ListNode[queue.size()];

    int i = 0;
    while (!queue.isEmpty()) {
        nodes[i++] = queue.poll();
    }

    for (int j = 0; j < nodes.length - 1; j++) {
        nodes[j].next = nodes[j + 1];
    }

    nodes[nodes.length - 1].next = null;

    return nodes[0];
}

更优解：借助了本身有序的特性，以及递归的思想：

public ListNode mergeTwoListsTraverse(ListNode l1, ListNode l2) {
    	// 递归边界
        if (l1 == null) return l2;
        if (l2 == null) return l1;
        if (l1.val < l2.val) {
            // 如果l1的值更小，满足升序，这时只需要将l1的下个结点与l2进行比较即可
            // l1的下一个链表链条即是两个链表结合过后的链条
            l1.next = mergeTwoListsTraverse(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoListsTraverse(l1, l2.next);
            return l2;
        }
    }

删除链表的重复结点

重点： 递归条件来源 – 当遍历到达尾部的时候停止

中间操作： 删除下一个结点的重复结点 — 这个是从尾部到头部

返回的确认：当有相等的值，则将head.next压栈，进行删除操作，直到最后出栈头部结点

递归是一个入栈的操作

public ListNode deleteDuplicates(ListNode head) {
    if(head == null || head.next == null) return head;
    head.next = deleteDuplicates(head.next);
    return head.val == head.next.val ? head.next : head;
}

删除倒数第N个结点

注意：

• 哑结点的作用 – 避免列表只有一个结点的情况出现。用于存储一个头结点
• 第二次遍历的时候，从哑结点开始遍历

public ListNode removeNthFromEnd2(ListNode head, int n) {
    // 哑结点--避免出现列表只有一个结点的情况
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    int length = 0;
    ListNode first = head;
    while (first != null) {
        length++;
        first = first.next;
    }
    first = dummy;
    length -= n;
    while (length > 0) {
        length--;
        first = first.next;
    }
    first.next = first.next.next;
    // 头结点
    return dummy.next;
}

还有一次遍历法 – 方法类似双指针

交换链表中的相邻结点

重点：

• 哑结点的使用，用在头部，使头部结点可以更换
• 中间结点储存结果
• 如果链接一个头部变换过的节点

public ListNode swapPairs(ListNode head) {
    // 哑结点代替头部，可以更换头部结点
    ListNode dummy = new ListNode(-1);
    dummy.next = head;

    ListNode pre = dummy;
    while (pre.next != null && pre.next.next != null) {
        ListNode l1 = pre.next, l2 = pre.next.next;

        // 中间结点, 用于存储节点的转移位置
        ListNode next = l2.next;
		// 执行结点翻转操作
        l1.next = next;
        l2.next = l1;

        // 指针重接
        pre.next = l2;
        pre = l1;
    }
    return dummy.next;
}

链表求和

tips：一般需要逆序求解的时候都需要用到栈来进行辅助。

• 中间链表插入结点，需要熟记，凡是最后需要返回头结点的，都需要有一个dummy结点作为固定指针位
• 链表的逆序求解，需要借助栈进行

public ListNode addTwoNumbers2(ListNode l1, ListNode l2) {
    Stack<Integer> stack1 = buildStack(l1);
    Stack<Integer> stack2 = buildStack(l2);
    // 头部固定指针位
    ListNode head = new ListNode(-1);
    // 计算进位
    int carry = 0;
    while (!stack1.isEmpty() || !stack2.isEmpty() || carry != 0) {
        // 通过三元表达式判定，当栈为空时，返回0，否则栈顶出栈
        int num1 = stack1.isEmpty() ? 0 : stack1.pop();
        int num2 = stack2.isEmpty() ? 0 : stack2.pop();
        int sum = num1 + num2 + carry;
        ListNode node = new ListNode(sum % 10);
        // 插入链表结点
        node.next = head.next;
        head.next = node;
        // 进位计算
        carry = sum / 10;
    }
    return head.next;
}

// 链表只能从左至右添加，但是需要从右至左遍历的时候，需要借助栈
private Stack<Integer> buildStack(ListNode node) {
    Stack<Integer> stack = new Stack<>();
    while (node != null) {
        stack.push(node.val);
        node = node.next;
    }
    return stack;
}

回文链表

判断一个链表是否是一个回文链表

关键：

• 通过两个指针结点进行切分（双指针法 – 经常用于求一半的问题中）
• 对于需要比较的部分通过反转链表，将后半部分反转再进行比较

public boolean isPalindrome(ListNode head) {
    ListNode slow = head, fast = head;
    // 记录走的长度
    int len = 0;
    // 用两个指针 -- 一个一次走一步，一个一次走两步.
    // 第二个结点恰好走了第一个结点的两倍路程
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        len++;
    }
    // 奇数个结点
    if (fast != null) slow = slow.next;
    // 反转链表
    slow = reverse(slow);
    while (len > 0) {
        if(head.val != slow.val)
            return false;
        head = head.next;
        slow = slow.next;
        len--;
    }
    return true;
}

// 如何反转链表，还需要加强
private ListNode reverse(ListNode head) {
    ListNode pre = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = pre;
        pre = head;
        head = next;
    }
    return pre;
}

分隔链表

关键是在于分区大小的确定。

• 首先还是要取得总个数，通过取模和取余，将模数和余数结合来确定分区大小
• 由于最多比分区大1，考虑用一个三元表达式来完成。
• 通过测试得到，当模数为2时，前两个分区会比其他分区大于1.
• 考虑将模数递减，直到为非正数时，其后的所有分区大小都比前面小1

public ListNode[] splitListToPartsWrong(ListNode root, int k) {
    ListNode[] nodes = new ListNode[k];
    ListNode p = root;
    // 获取结点的总个数
    int N = 0;
    while (p != null) {
        p = p.next;
        N++;
    }
    // 获取模数和每个小块的大小，来确定每个分区大小
    int mod = N % k, size = N / k;
    for (int i = 0;root != null && i < k; i++) {
        ListNode cut = root;
        // 模数大于0时，前面的要比后面的多一个
        int m = size + (mod-- > 0 ? 1 : 0);
        // 注意链表的截断操作
        for (int j = 0; j < m - 1; j++)
            cut = cut.next;
        nodes[i] = root;
        root = cut.next;
        cut.next = null;
    }
    return nodes;
}

奇偶链表

核心：

• 需要的空间复杂度为O(1)，因此只能考虑用单个结点作为中间存储，不能使用栈和队列等辅助
• 由于有一个截断操作，需要用哑结点来作为临时的存储
• 中间的遍历操作简单，用原地算法进行操作，不开辟额外的空间

在计算机科学中，一个原地算法（in-place algorithm）是一种使用小的，固定数量的额外之空间来转换资料的算法。当算法执行时，输入的资料通常会被要输出的部份覆盖掉。不是原地算法有时候称为非原地（not-in-place）或不得其所（out-of-place）。

public ListNode oddEvenList(ListNode head) {
    if (head == null || head.next == null) return head;

    ListNode odd = head, even = head.next;

    ListNode dummy1 = new ListNode(-1), dummy2 = new ListNode(-1);
    // 哑结点分别存储奇数链表和偶数链表的表头
    dummy1.next = odd;
    dummy2.next = even;
	// 由于总是偶数结点先抵达，因此只需要对偶数进行判定
    while (even != null && even.next != null) {
        ListNode temp1 = odd, temp2 = even;
        odd = odd.next.next;
        even = even.next.next;
        temp1.next = odd;
        temp2.next = even;
    }
    // 将偶数链表插在奇数的尾部
    odd.next = dummy2.next;
    return dummy1.next;
}