2021-06-28

记录自己LeetCode学习过程

2021.6.28

1.解决链表反向输出（LC206）

• 给你单链表的头结点head,求反转后的链表。

1. 之前思路：使用node、new_node,并用rem记录new_node。
   在更新new_code->next之前用rem记忆new_code,
   使得原先后面的结点信息不会丢失。
   运行出错，这是因为rem=node->next，当new_code变化后，rem中也会变化。后面大佬代码中rem=pre->next，存储了pre下一个指针，这样再修改pre内容时，不会影响。

 class Solution {
 public:
     ListNode* reverseList(ListNode* head) {
         ListNode* node = head;
         ListNode* new_node = head;
         ListNode* rem = head;
        
         while(1){
             new_node = node->next;
             rem = node->next;
             if(new_node == nullptr) break;
             if(node == head) node->next = nullptr;

             new_node->next = node;
             node = rem;
         }
         return node;
     }
 };

2. 查阅到的大佬代码

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = NULL, *pre = head;
        while (pre != NULL) {
            ListNode* t = pre->next;
            pre->next = cur;
            cur = pre;
            pre = t;
        }
        return cur;
    }
};

对比自己的，大佬记忆的是最前面的，即pre->next,而且初始化很简洁美观，while循环也很美观。

3. 修改后自己的代码：

   class Solution {
   public:
   ListNode* reverseList(ListNode* head) {
   ListNode* node = NULL;
   ListNode* new_node = head;
   ListNode* rem = head;
   while(new_node != NULL){
       rem = new_node->next;
       new_node->next = node;
       node = new_node;
       new_node = rem;
       }
   return node;
     }
   };
   

4. 总结：链表问题画图是很好的方法，可以捋清思路。大佬说面试中很多人不能写出这几句代码，多写才能很好掌握。

2.寻找链表环（LC141）

• 给定一个链表，判断链表中是否有环。

   主要思路：快指针与慢指针。快指针每次走两步，慢指针每次走一步。
   快指针每次比慢指针多走一步，若两者相遇说明有环。
   注意考虑很多特殊情况。
  

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode *fast,*slow;
        fast = slow = head;
        do{
            if(fast==NULL || fast->next == NULL)
            return false;
            else if(fast->next->next == NULL)
            return false;
            else{
            fast = fast->next->next;
            slow = slow->next;
            if(fast==slow) return true;}
        }while(fast != NULL || slow != NULL);
        return false;
    }
};

3.合并两个有序链表（LC21）

• 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
      ListNode* prehead = new ListNode(0);
      ListNode* NewList = prehead;
      
      while(l1!=NULL&&l2!=NULL){
        if(l1->val<=l2->val)
          {NewList->next = l1;
          l1=l1->next;}
        else {NewList->next = l2;
           l2 = l2->next;}
        NewList = NewList->next;}
        NewList->next = (l1 == NULL) ? l2 : l1; 
    
      return prehead->next;

    }
};

• 学到的芝士：

1. new ListNode(0) 是链表初始化为0。当链表为空时，会返回0。
2. prehead是一个虚拟的头结点之前的结点，可以使得头结点的操作和后面的节点操作一致，更简洁。只需返回prehead->next即可。
3. NewList->next = (l1 == NULL) ? l2 : l1; 简洁美观。