《六月集训》（第十二天）——链表

前言

        欢迎大家积极在评论区留言发表自己的看法，知无不言，言无不尽，养成每天刷题的习惯，也可以自己发布优质的解题报告，供社区一同鉴赏，吸引一波自己的核心粉丝。
        今天是六月集训第十二天：链表🔥🔥🔥

一、练习题目

        328. 奇偶链表
        725. 分隔链表
        817. 链表组件
        622. 设计循环队列

二、算法思路

• 1、328. 奇偶链表：直接上一个数组了🔥
• 2、725. 分隔链表：先统计出链表的总长度，记为cnt，利用$pre=cnt/k$尽可能的均匀分割链表，但是不一定完全能分割开的，肯定有余数，利用rem = cnt % k，前rem个数使得长度为pre+1，后面k - rem个数只要取pre就可以了。🔥🔥
• 3、817. 链表组件：利用一个哈希表来做。🔥
• 4、622. 设计循环队列：利用单向链表来模拟🔥

三、源码剖析

// 328. 奇偶链表
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        ListNode* virtualhead;
        vector<ListNode*> tmp;

        while(head){
            tmp.push_back(head); //（1）
            head = head->next;
        }
        virtualhead = new ListNode();
        head = virtualhead;
        for(int i = 0; i < tmp.size(); i+=2) {
            head->next = tmp[i];
            head = head->next;
        } //（2）

        for(int i = 1; i < tmp.size(); i+=2) {
            head->next = tmp[i];
            head = head->next;
        } //(3)
        head->next = nullptr; //(4)
        return virtualhead->next;
    }
};

• 1、建立一个存储链表结点的数组，将结点依次存入到数组中；
• 2、两次遍历，首先将奇数索引的值先连起来；
• 3、再将偶数索引的值连起来；
• 4、注意最后要一个末尾连上一个空指针。

// 725. 分隔链表
clclass Solution {
public:
    vector<ListNode*> splitListToParts(ListNode* head, int k) {
        vector<ListNode*> ret;
        int cnt = 0; 
        ListNode* p = head;
        while(p){
            p = p->next;
            cnt++; //(1)
        }

        ListNode* prehead = new ListNode();
        int pre = cnt / k;
        int rem = cnt % k;
        for(int i = 0; i < rem; ++i) { //(2)
            ret.push_back(head);
            int c = pre + 1;
            while(c--) {
                prehead = head;
                head = head->next;
            }
            if(prehead) { //(3)
                prehead->next = nullptr;
            }
        }

        for(int i = 0; i < k - rem; ++i) { //(4)
            ret.push_back(head);
            int c = pre;
            while(c--) {
                prehead = head;
                head = head->next;
            }
            if(prehead) {
                prehead->next = nullptr;
            }
        }

        return ret;
    }
};

• 1、统计链表中的结点数；
• 2、根据题意数组前半部分尽可能的长，所以前rem个数取平均值加一的数；
• 3、利用prehead指针作一刀两段的工作，切掉和后面的联系；
• 4、k - rem个数只要按照pre的长度截取就可以了。

// 817. 链表组件
class Solution {
public:
    int numComponents(ListNode* head, vector<int>& nums) {
        int hash[10005];
        memset(hash, 0, sizeof(hash));
        for(auto i : nums) {
            hash[i]++;
        } //(1)

        int cnt = 0, pre = 0;
        while(head){
            if(hash[head->val]) {
                pre = 1; 
            }else {
                if(pre == 1)
                    cnt++;
                pre = 0;
            }//(2)
            head = head->next;
        }
        if(pre == 1) { //(3)
            ++cnt;
        }
        return cnt;
    }
};

• 1、建立哈希表存储nums中的元素；
• 2、在原链表中查找，，如果是在哈希表中的pre置为1，否则判断pre的值，如果pre是1说明前面有一段连续的存在nuns中的链表值，计数器加一；
• 3、最后，链表遍历完了以后如果pre还是1，计数器还需要再累加一次，判断末尾的是不是。

// 622. 设计循环队列
class MyCircularQueue {
    ListNode* front, *rear;
    int size, capacity;
public:
    MyCircularQueue(int k) {
        front = rear = nullptr;
        size = 0;
        capacity = k;
    }
    
    bool enQueue(int value) {
        if(isFull()) {
            return false;
        }
        if(rear == nullptr) {
            front = rear = new ListNode(value);
        } else {
            rear->next = new ListNode(value);
            rear = rear->next;
        }
        ++size;
        return true;
    }
    
    bool deQueue() {
        if(isEmpty()) {
            return false;
        }
        front = front->next;
        --size;
        if(isEmpty()) {
            front = rear = nullptr;
        }
        return true;
    }
    
    int Front() {
        if(isEmpty()) {
            return -1;
        }
        return front->val;
    }
    
    int Rear() {
        if(isEmpty()) {
            return -1;
        }
        return rear->val;
    }
    
    bool isEmpty() {
        return size == 0;
    }
    
    bool isFull() {
        return size == capacity;
    }
};

• 1、单向链表模拟循环队列。