LeetCode Day 12

LeetCode0024

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:

给定 1->2->3->4，你应该返回 2->1->4->3.

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var swapPairs = function (head) {
    let dummy = new ListNode();
    dummy.next = head;
    let parent = dummy;
    while (head) {
        let next = head.next;
        if (!next) break;
        let next2 = next.next;
        //交换了节点
        next.next = head;
        head.next = next2;
        parent.next = next;
        //重新制定head和parent,注意是两两交换而不是挨个交换
        parent = head;
        head = next2;
    }

    return dummy.next;
};

结果：

执行用时 ：60 ms, 在所有 JavaScript 提交中击败了87.62%的用户

内存消耗 ：33.9 MB, 在所有 JavaScript 提交中击败了11.69%的用户

LeetCode0025

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明 :

• 你的算法只能使用常数的额外空间。
• 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

空间复杂度，顾名思义，就是你的程序要用多少个内存空间。但这并不是一个具体的数字，因为谁也不知道你的程序真正会具体用到多少字节，所以这只是一个大概的评价算法的一个概念。

无论你的程序是用1字节内存还是1亿字节内存，只要这个数字是确定的，你都可以说你的程序的空间复杂度是O(1)，这代表你要使用的空间一个常数，而不是特指1，常数代表所需的空间在程序运行中不会改变。

但是如果你的程序是输入n个数据并且分配n个空间，那么空间复杂度就是O(n)，因为这个n我们不知道程序在真正运行中到底输入多少数据，你输入10个也行，输入100亿个也行，因为我们不知道所以动态的说是要用到n个空间，就算输入n个数据，每个数据要用到1000个字节内存，我们也只说空间复杂度是O(n)，因为1000是一个固定的数字，或者说常数，这个常数不会随输入数据量n的变化而变化，我们只关注动态的会变的那个n而已。（我们有时候也在这种情况下说复杂度是O(n*c)，就是大O，n乘以c，c代表的是一个常数，在这个例子中就是1000，不过一般情况下不这么说，因为和不会变的常数c相比n往往大得多的多，所以我们一般简写O(n)而已）

如果需要输入n个数据，每个数据因为需要和其他n个数据联系，所以要分配n*n个空间，或者说n的平方的空间，我们就说O(n*n)，或者说O(n^2)（指n的2次幂）个空间复杂度，这也是因为n是未知的。

思路：

• 说到倒序很容易就想到栈了，我先push进K个listNode，满足k个就往外pop并且连接起来；
• 不够K个就直接组合输出。
• 先试试算不算满足常数的额外空间，LeetCode应该会有空间复杂度的验证；

/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
var reverseKGroup = function (head, k) {
    let dummy = new ListNode();
    let result = dummy;
    let stack = [];
    let count = 0;
    while (head) {
        stack.push(head);
        head = head.next;
        count++;
        if (count === k) {
            while (count > 0) {
                dummy.next = stack.pop();
                dummy = dummy.next;
                dummy.next = null;
                count--;
            }
        }
    }

    if (stack.length > 0) {
        dummy.next = stack[0];
    }
    return result.next;
};

结果：

执行用时 ：84 ms, 在所有 JavaScript 提交中击败了87.12%的用户

内存消耗 ：38.3 MB, 在所有 JavaScript 提交中击败了5.36%的用户

看这个结果应该是空间复杂度不满足常数级别，也就是说我们设置的stack栈，它的长度其实是按K值变长的，果然不行，我们重新思考。