数据结构学习笔记丨链表 - Day 2

跟朋友提起我在看链表，于是他让我做一做Leetcode 206，21，141练练手。

于是我先做了206，这是一道把单链表反向的题目，号称最简单链表题。首先我自己的思路是，把一个个node单独拿出来，然后不断给它们增加next的联系。通过是通过了，run time也击败了100%的人。但是看到大神们的solution还是思路有点问题。

贴上大神代码：

public ListNode reverseList(ListNode head){ 

 ListNode prev =null; 

 ListNode curr = head;

while(curr !=null) { 

 ListNode nextTemp = curr.next; 

 curr.next = prev; 

 prev = curr; 

 curr = nextTemp; }

return prev;}

大神的思路是不单单把它看做单链表，我们可以建立一个点只存curr点的prev。这样就相当于，我们只是在当前的链表上移动，只不过每到一个curr，就把它与之前那个点的next关系翻转调换一下。

比我那个，单独再建一条新表的思路高明的多。

另外还有一个递归思想的解法。

public ListNode reverseList(ListNode head){

if(head ==null|| head.next ==null) return head;

ListNode p = reverseList(head.next);

head.next.next = head;

head.next =null;

return p;}

这个理解起来稍微有点复杂，总的来说就是，reverseList这个方法就只做了一件事，就是把k+1点的link给翻转过来，然后拆掉原有的link。

假设前面的m到k+1这些点的link已经被修正好了

前面一直在调用这个方法，是从链表的头一直遍历往后到最后一个点，然后从最后一点开始，一个个把两个点之间的link关系翻转，再直到原来的头结点。

之后我去做了21，这是一道把两条有序单链表合并成一条有序单链表的题目。其实仔细想想，去年上算法题的时候，老师好像有讲过这个例子。但是我完全忘得一干二净了。然后思路超级混乱，一会想着把一条链表插入另一条（因为想利用这个已经有序的优势），一会疯狂想着怎样互相比较这两条链表里的元素，比如list1node1和list2node1比完之后大的那个再和另一个链表里的node2比，然后想来想去也不知道怎么循环到底哪一条链表。

其实最简单的思路是，放弃利用已有的两条，新建一条，确定了当前两点最小值，才把它link到新链表中。

经过这两道题的训练，我发现单链表最重要的思路一定是当前指针位置。确定了之后才去管两个点之间的联系，而不是一开始就想着把这个点link到哪里去。

继续贴上学习的大神代码：

递归版：

class Solution {

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        if (l1 == null) {

            return l2;}

        else if (l2 == null) {

            return l1; }

        else if (l1.val < l2.val) {

            l1.next = mergeTwoLists(l1.next, l2);

            return l1;}

        else { l2.next = mergeTwoLists(l1, l2.next);

            return l2; }}}  

递归版的中心思想就是不断比较当前L1和L2指针所在node的大小，然后把小的link上在下一个比较出的小值上。（递归真的好难自己想出来啊。。。感觉只能事后去理解）

感觉递归就是，一次只做一件事，找出一个题目中最小的重复单元，然后把返回结果套结果。但是跟迭代又不太一样。

未完待续...后来我又做了141，这个是一个单链循环链表，思路对于我来说有点难。但是知道了之后就能举一反三，之后做了happy number这道题，跟141用的思路是一样的。就是如何check一组数/一个链表，是否有循环。

---

更新：

果然做算法题，就是要温故而知新，多看大神的讨论和解法。又去看了一下happy number（202）和单链循环（141），发现检测是否循环的这个算法还是一个挺有名的算法，名为 Floyd Cycle Detection。它的具体思路是，如果一个集合（链表、数组）中存在循环，那么假设有一个跑的快的指针 A和跑的慢的指针 B，在遍历这个集合时，他们一定会在某个地方相遇（遍历到同一个点or数）。就像小学时的追击问题一样，两个人在同一个地方跑圈，跑得快的总是会在某个地方追上跑的慢的。

所以以单链循环为例，指针A一次遍历两个点，指针B一次遍历一个点。然后A,B开始赛跑，在相遇（有循环）或者到尾节点时（没循环）之前他们不会停下。

int A= B = head；

while(slow != null && fast != null){

            slow = slow.next;

            try{ fast = fast.next.next; }catch(Exception e){ //如果报错说明链表有限

                return false; }

            if(slow == fast){

                return true;} }

        return false;

---

通过这几道题的学习，感觉算法学习是一个又一个的算法思路积累的过程。我刚听到我同学告诉我141的解题思路时，我是震惊的，谁能凭空想到啊！结果我去查了一下，发现这是一个已经被熟知的大众检测循环的思路。

说到底还是积累的太少。就像加法还没学好，怎么可能学得好乘法一样。慢慢学习积累的思路，算法多了，就能像背九九乘法表一样把要用的知识随时抽出来杂糅在一起，做出三位数的乘法！（能够解决多个算法运用在一起的实际问题！）