LEETCODE刷题记录----------暑假篇

。

LEETCODE刷题记录

①合并两个有序链表

下面展示 代码。

// 迭代法
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) 
    {
        ListNode *l3 = new ListNode(-1);    //关键点，下次建表别再忘记了！
        ListNode *p = l3;
        while(l1 && l2)
        {
        if(l1->val <= l2->val)
        {
            p->next = l1;
            l1 = l1->next;
            p = p->next;
        }
        else {
            p->next = l2;
            l2 = l2->next;
            p = p->next;
        }
        }
        p->next = l1==nullptr ? l2:l1;
        return l3->next;
     }

    // 递归法   (该方法比较抽象需要加以理解)  递归思想还需培养 T-T
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == nullptr) {
            return l2;
        } else if (l2 == nullptr) {
            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;
        }
    }

②相交链表

题目如下：

下面展示 代码。

// 双指针相遇法（一次完美浪漫的邂逅）
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
    {
        ListNode *p=headA;
        ListNode *q=headB;
        if(headA == NULL || headB == NULL) return NULL;
        while(p != q)      // 此处务必注意不要用val来比较，还需考虑到next指针的存在
        {
            p = p == NULL ? headB : p->next;
            q = q == NULL ? headA : q->next;
        }
        return p;
    }


  //暴力法省略

③环形链表（判断链表中是否存在环）

//快慢指针之圆环追及问题（一个字秒啊！）
 bool hasCycle(ListNode *head) 
 {
    if(head == NULL) return false;
    ListNode *fast = head->next;
    ListNode *slow = head;
 
   while( slow!=fast ) 
   {
      if(fast==NULL || fast->next==NULL)  return false;
      fast = fast->next->next;
      slow = slow->next;
   }
   return true;
 }

// 哈希法(太慢了，除非无路可走，效率太低了）
    bool hasCycle(ListNode *head) 
    {
        unordered_map <ListNode *,int> hash;       //奇怪的知识又增加了，虽然还没进一步理解
       while(head)
       {
           hash[head]++;
           if(hash[head]>1) return true;
           head = head->next;
       }
       return false;
    }

// set容器法（缺点也是很明显，太慢了)       
    bool hasCycle(ListNode *head) 
    {
        set<ListNode *> s;        //get到了一个新点，set容器储存只识别主关键字，相同的节点加入size不发生改变
        ListNode *p = head;
        int count = 0;
        while(p)
        {
            s.insert(p);
            if(count == s.size()) return true;
            count =s.size();
            p = p->next;

        }
        return false;
    }