【Cracking the Code Interview(5th edition)】二、链表(C++)

链表结点类型定义：

class Node {
public:
    int data = 0;
    Node *next = nullptr;
    
    Node(int d) {
        data = d;
    }
};

快行指针(runner)技巧：

同时使用两个指针来迭代访问链表，其中一个比另一个超前一些。快指针比慢指针先行几步或者快指针与慢指针的速度呈一定的关系。

dummy元素技巧：

在链表头部添加一个哑结点，通常可以简化首部或尾部的特殊情况的处理。

---

 2.1 编写代码，移除未排序链表中的重复结点。

进阶：如果不得使用临时缓冲区，该怎么解决？

解答：如果可以使用临时缓冲区，那么可以建立一个Hash表，保存已出现的结点内容，遍历过程中如果发现重复元素，就删除该结点。

void deleteDups(Node *head) {
    if (head == nullptr) return;
    unordered_set<int> table;
    Node *f = head, *p = head->next;
    table.insert(head->data);
    while (p != nullptr) {
        if (table.find(p->data) == table.end()) {
            table.insert(p->data);
            f = p;
            p = p->next;
        }
        else {
            f->next = p->next;
            delete p;
            p = f->next;
        }
    }
}

如果不允许使用额外的数组，则暴力解决..

void deleteDups(Node *head) {
    if (head == nullptr || head->next == nullptr) return;
    Node *f = head, *p = head->next;
    while (p != nullptr) {
        Node *pc = head;
        while (pc != p) {
            if (pc->data == p->data) {
                f->next = p->next;
                delete p;
                p = f;
                break;
            } else {
                pc = pc->next;
            }
        }
        p = p->next;
    }
}

---

 2.2 实现一个算法，找出单向链表中倒数第k个结点。

解答：利用快行指针技巧，让快指针先走k步，然后同步地挪动快慢指针，快指针到达链表尾时，慢指针恰好指向倒数第k个结点。(剑指offer上也有这道题)

Node * kthToLast(Node *head, int k) {
    if (k < 0) return nullptr;
    Node *p1 = head, *p2 = head;
    for (int i = 0; i < k - 1; ++i) {
        if (p2 == nullptr || p2->next == nullptr) 
            return nullptr;
        p2 = p2->next;
    }
    while (p2->next != nullptr) {
        p1 = p1->next;
        p2 = p2->next;
    }
    return p1;
}

---

2.3 实现一个算法，删除单链表中的某个结点，假定你只能访问该结点。

解答：本题的意思是我们不知道链表的首结点位置。那么删除该结点的方法是：将其后继结点的值赋给该节点，然后删除后继结点。有一个问题是：如果给定的结点指针是空指针或是最后一个指针时会出错，我们可以通过程序的返回值来指明错误或抛出异常。

bool deleteNode(Node *node) {
    if (node == nullptr || node->next == nullptr) {
        return false;
    }
    Node *next = node->next;
    node->data = next->data;
    node->next = next->next;
    delete next;
    return true;
}

---

2.4 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之间。

解答：维护两个链表，分别保存大于x和小于x的元素，然后将两个链表连接起来。尾插法可以保持元素的相对位置。加入dummy结点可以简化代码。Leetcode上也有这道题。

Node * partition(Node *head, int x) {
    Node dummy_left(-1), dummy_right(-1);
    Node *pl = &dummy_left, *pr = &dummy_right;
    for (Node * p = head; p != nullptr; p = p->next) {
        if (p->data < x) {
            pl->next = p;
            pl = pl->next;
        } else {
            pr->next = p;
            pr = pr->next;
        }
    }
    pl->next = dummy_right.next;
    pr->next = nullptr;
    return dummy_left.next;
}

---

2.5 给定两个用链表表示的整数，每个结点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。

进阶：假设这些数位是正向存放的，请再做一遍。

反向表示举例：(Leetcode)

7->1->6

+

5->9->2->1

___________________

2->1->9->1

Node * addList(Node *l1, Node *l2) {
    Node dummy(-1);
    Node *p = &dummy;
    int carry = 0;    //进位
    while (l1 != nullptr || l2 != nullptr) {
        int v = 0;
        if (l1 != nullptr) {
            v += l1->data;
            l1 = l1->next;
        }
        if (l2 != nullptr) {
            v += l2->data;
            l2 = l2->next;
        }
        v += carry;
        carry = v / 10;
        v = v % 10;
        Node *node = new Node(v);
        p->next = node;
        p = p->next;
    }
    if (carry > 0) {
        Node * node = new Node(carry);
        p->next = node;
        p = p->next;
    }
    return dummy.next;
}

 进阶问题：可以借助一个栈实现，或者先通过填零把两个链表的长度变为一致，然后递归求解。以下是后一种思路的代码：(partialSum是一个包裹类，把一个Node指针和一个表示进位的int捆绑在一起，方便函数返回)。把独立的处理逻辑分列到不同的函数中，使代码思路清晰，可读性强。

class partialSum {
public:
    Node * node = nullptr;
    int carry = 0;
};

int length(Node *l) {
    int len = 0;
    while (l != nullptr) {
        ++len;
        l = l ->next;
    }
    return len;
}

Node * padList(Node *l, int n) {
    //填零
    Node * new_head = l;
    for (int i = 0; i < n; ++i) {
        Node *node = new Node(0);
        node->next = l;
        new_head = node;
    }
    return new_head;
}

partialSum * addListHelper(Node *l1, Node *l2) {
    partialSum *sum = new partialSum;
    if (l1->next == nullptr && l2->next == nullptr) {
        int v = l1->data + l2->data;
        sum->node = new Node(v % 10);
        sum->carry = v / 10;
        return sum;
    }
    else {
        partialSum *part_sum = addListHelper(l1->next, l2->next);
        int v = l1->data + l2->data + part_sum->carry;
        sum->node = new Node(v % 10);
        sum->carry = v / 10;
        sum->node->next = part_sum->node;
    }
    return sum;
}

Node * addList(Node *l1, Node *l2) {
    int len1 = length(l1);
    int len2 = length(l2);
    if (len1 < len2)
        l1 = padList(l1, len2 - len1);
    else if (len1 > len2)
        l2 = padList(l2, len1 - len2);
    if (l1 == nullptr && l2 == nullptr)
        return nullptr;
    partialSum *sum = addListHelper(l1, l2);
    if (sum->carry > 0) {
        Node *node = new Node(sum->carry);
        node->next = sum->node;
        return node;
    } else return sum->node;
}

---

2.6 给定一个有环链表，实现一个算法返回环路的开头结点。

解答：链表环图示：

第一种方法：类似于找一个数组或链表中的重复元素的问题，这里实际上要找一个链表中next指针的重复问题(也可以与head重复)。所以同样可以用hash表解决，但是需要一定的额外存储空间。

Node * findLoopBeginning(Node *head) {
    unordered_set<Node *> table;
    while (head != nullptr) {
        if (table.find(head) != table.end()) {
            return head;
        } else {
            table.insert(head);
            head = head->next;
        }
    }
    return nullptr;
}

第二种方法：如果不允许用额外的数组空间，那么还有另一种技巧性比较强的方法：快慢指针法。

首先：如何判断是否有环？定义两个指针fast和slow，以不同的速度遍历链表。fast每次走两步，slow每次走一步，这样如果链表存在环，则两个指针一定会相遇。而且相遇的位置在环内。

然后：环入口点怎么找？当fast若与slow相遇时，slow肯定没有走遍历完链表，而fast已经在环内循环了n圈(1<=n)。假设slow走了s步，则fast走了2s步（fast步数还等于s 加上在环上多转的n圈），设环长为r，则：
2s = s + nr
s= nr
设整个链表长L，入口环与相遇点距离为x，起点到环入口点的距离为a。
a + x = nr
a + x = (n – 1)r +r = (n-1)r + L - a
a = (n-1)r + (L – a – x)
(L – a – x)为相遇点到环入口点的距离，由此可知，从链表头到环入口点等于(n-1)循环内环+相遇点到环入口点，于是我们从链表头、与相遇点分别设一个指针，每次各走一步，两个指针必定相遇，且相遇第一点为环入口点。

Node * findCircleBeginning(Node *head) {
    Node *fast = head, *slow = head;
    while (fast && fast->next) {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) {
            break;
        }
    }
    if (fast == nullptr || fast->next == nullptr) {
        return nullptr;
    }
    slow = head;
    while (slow != fast) {
        slow = slow->next;
        fast = fast->next;
    }
    return slow;
}

---

2.7 编写一个函数，检查链表是否是回文(正看反看相同)。

解答： 

方法1：反转链表，判断与原链表是否一致，实际上只需判断两个链表的前面一半即可。

方法2：反转链表的前半部分，与后半部分比较，借助栈来实现。

bool isPalindrome(Node *list) {
    Node *fast = head, *slow = head;
    stack<int> s;
    while (fast != nullptr && fast->next != nullptr) {
        s.push(slow->data);
        slow = slow->next;
        fast = fast->next->next;
    }
    if (fast != nullptr) {
        slow = slow.next;
    }
    while (slow != nullptr) {
        if (s.top() != slow->data) {
            return false;
        }
        slow = slow->next;
    }
    return true;
}

方法3：递归，逐层判断收尾对应元素是否相等。如：0(1(2(3)2)1)0。

class Result {
public:
    Node *node = nullptr;    //该段后接的第一个结点
    bool result = false;    //该段是否满足回文性质
};


Result isPalindromeRecurse(Node *list, int length) {
    Result ret;
    if (length <= 0) {
        ret.result = true;
    }
    else if (length == 1) {
        ret.node = list->next;
        ret.result = true;
    }
    else if (length == 2) {
        ret.node = list->next->next;
        ret.result = (list->data == list->next->data);
    }
    else {
        Result part_ret = isPalindromeRecurse(list->next, length - 2);
        if (part_ret.result == false) {
            ret.node = nullptr;
            ret.result = false;
        }
        else {
            ret.node = part_ret.node->next;
            ret.result = (list->data == part_ret.node->data);
        }
    }
    return ret;
}
bool isPalindrome(Node *list) {
    return isPalindromeRecurse(list, length(list)).result;
}