代码随想录-链表

代码随想录-链表

预备知识

coding

day3

• 206. 反转链表

      ListNode* reverseList(ListNode* head) {
      if(head == nullptr || head->next == nullptr){
          return head;
      }
      ListNode* cur = reverseList(head->next);
      // head->next 是当前head的下一个节点B B->head
      head->next->next = head;
      head->next = nullptr;
      return cur;
  }
  

• 203. 移除链表元素

      ListNode* removeElements(ListNode* head, int val) {
      if(head == nullptr) return head;
      ListNode* mock = new ListNode();
      mock->next = head;
      ListNode* pre = mock, *current = head;
  
      while(current != nullptr){
          if(current->val == val){
              pre->next = current->next;
          }else{
              pre = current;
          }
          current = current->next;
      }
      pre = mock->next;
      delete mock;
      return pre;
  }
  

• 707. 设计链表
  

头铁要写不带头节点的链表，结果一直报空指针问题，查看len和实际链表对不上了
bug代码

class MyLinkedList {
public:
    struct Node{
        Node(int value){
            val = value;
            next = nullptr;
        }
        Node(int value, Node* next_node){
            val = value;
            next = next_node;
        }
        int val;
        Node* next;
    };


    MyLinkedList() {
        len_ = 0;
        head_ = nullptr;
        tail_ = nullptr;
    }
    
    void Print(){
        Node* p = head_;
        std::cout << " [Print] len=" << len_ << ",detail=";
        while(p != nullptr){
            std::cout << p->val << ",";
            p = p->next;
        }
        std::cout << endl;
    }
    int get(int index) {
        if(index >= len_ || index < 0) return -1;
        Node* current = head_;
        while(index-- > 0){
            current = current->next;
        }
        return current->val;
    }
    
    void addAtHead(int val) {
        head_  = new Node(val, head_);
        if(tail_ == nullptr){
            tail_ = head_;
        }
        ++len_;
    }
    
    void addAtTail(int val) {
        if(tail_ == nullptr){
            addAtHead(val);
            return;
        }
        tail_->next = new Node(val);
        tail_ = tail_->next;
        ++len_;
    }
    
    void addAtIndex(int index, int val) {
        if(index > len_ || index < 0) return;
        if(index == 0){
            addAtHead(val);
            return;
        }
        if(index == len_ ){
            addAtTail(val);
            return;
        }

        Node* pre = head_;
        while(--index > 0){
            pre = pre->next;
        }
        pre->next = new Node(val, pre->next);
        ++len_;
    }
    
    void deleteAtIndex(int index) {
        if(index >= len_ || index < 0) return;
        std::cout << "before del index=:" << index;
        Print();
        // 删除头节点
        Node* obj = nullptr;
        if(index == 0){
            obj = head_;
            if(head_ != tail_){
                head_ = head_->next;
            }else{
                head_ = nullptr;
                tail_ = nullptr;
            }
        }else{
            Node* pre = head_;
            while(--index > 0){
                pre= pre->next;
            }
            obj = pre->next;
            pre->next = pre->next->next;
            if(pre->next == nullptr){
                tail_ = nullptr;
            }
        }
        delete obj;
        --len_;
        std::cout << "after del:";
        Print();
    }


    private:
        int len_;          // 当前链表的长度
        Node* head_;          // 头节点
        Node* tail_;          //尾节点
};

day4

• 24. 两两交换链表中的节点
  
  注意不能让链表断开了

    ListNode* swapPairs(ListNode* head) {
        if(head == nullptr || head->next == nullptr){
            return head;
        }
        ListNode* pre = head, *current = nullptr, *ret = head->next;
        ListNode* last = new ListNode(0, head);
        while(pre != nullptr && pre->next != nullptr){
            current = pre->next;
            // 交换
            ListNode* tmp = current->next;
            current->next = pre;
            pre->next = tmp;
            // 连接前半段
            last->next = current;
            last = pre;
            // 移动
            pre = tmp;
        }
        return ret;
    }

• 19. 删除链表的倒数第 N 个结点
  

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head == nullptr) {return head;}
        if(head->next == nullptr && n > 0){return head->next;}
        ListNode* mock = new ListNode();
        mock->next = head;
        ListNode* slow = mock, *fast = mock;
        while(n--){
            fast = fast->next;
        }
        while(fast->next != nullptr){
            slow = slow->next;
            fast = fast->next;
        }
        auto* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        return mock->next;
    }

• 面试题 02.07. 链表相交
  

    int getListLength(ListNode* node) {
        if(node == nullptr){return 0;}
        int ret = 0;
        ListNode* tmp = node;
        while(tmp != nullptr){
            ++ret;
            tmp = tmp->next;
        }
        return ret;
    }
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // list A 长度 La = L1 + L3， L3为相交的公共部分
        // list B 长度 L吧= L2 + L3
        // 通过遍历,能够得到La Lb, 则可得 delta_L = La - Lb = L1 - L2
        // 长链表先走delta步,然后一起移动，若是相交则必定会遇到交点
        // 1. 能够得到La Lb 2. 判断哪个长
        int len_a = getListLength(headA);
        int len_b = getListLength(headB);
        int diff = std::max(len_a - len_b, len_b-len_a);
        ListNode* fast = len_a > len_b ? headA : headB;
        ListNode* slow = len_a > len_b ? headB : headA;

        while(diff--){
            fast = fast->next;
        }

        while(fast != slow && fast!= nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        return fast;
    }

• 142. 环形链表 II
  

    ListNode *detectCycle(ListNode *head) {
        if(head == nullptr || head->next == nullptr){
            return nullptr;
        }
        ListNode* slow = head, *fast = head;
        while(true){
            if(fast ==  nullptr || fast->next == nullptr){
                return nullptr;
            }
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast){
                break;
            }
        }
        // 确定存在环形
        ListNode* tmp = head;
        while(slow != tmp){
            tmp = tmp->next;
            slow = slow->next;
        }
        return tmp;
    }