leecode链表相关题目c++

203. 移除链表元素

思路：首先要考虑吧有两种情况，一种是头节点就是要删除的节点，需要单独处理，因为链表的删除操作是通过前一个节点来移除当前节点，但头节点没有前一个节点。
方法一：单独处理头节点的情况。处理完头节点再处理后面节点。
代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head != NULL && head->val == val){
            ListNode* tmp = head;  //处理头节点是被删除节点的操作
            head = head->next;
            delete tmp;  //手动清理
        }
        //删除不是头节点的节点
        ListNode* cur = head;
        while(cur != NULL && cur->next != NULL){ //当链表不为空也不为最后一个元素的时候
            if(cur->next->val == val){
                ListNode* tmp = cur->next;  //保留tmp是为了手动清除
                cur->next = cur->next->next;
                delete tmp;
            }
            else{
                cur = cur->next;
            }
        }
        return head;
    }
};

方法二：通过创建虚拟头节点，来统一处理链表。
代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* tmpHead = new ListNode(0);   //创建虚拟头节点
        tmpHead->next = head;   //将现有链表的头节点接到虚拟头节点后面
        
        ListNode* cur=tmpHead;
        while(cur != NULL && cur->next != NULL){
            if(cur->next->val == val){
                ListNode* tmp = cur->next;  //创建临时节点为了存储要清除的节点，以便清理内存
                cur->next = cur->next->next;
                delete tmp;  //手动清理
            }
            else{
                cur = cur->next;
            }
        }
        head = tmpHead->next;    //最后删除掉虚拟头节点
        delete tmpHead;
        return head;
    }
};

707. 设计链表

题目：

解答：
代码：

class MyLinkedList {
public:
    struct ListNode{
        int val;
        ListNode* next;
        ListNode(int val):val(val),next(nullptr){}
    };
    //初始化链表
    MyLinkedList() {
        dHead = new ListNode(0);  //虚拟头节点
        size = 0;
    }
    //获取第index位置的数据
    //如果索引小于0或者大于索引长度返回-1
    int get(int index) {
        if(index < 0 || index > size-1){
            return -1;
        }
        ListNode* cur = dHead->next;
        while(index--){ //向后移动n次数，就可到达index位置
            cur = cur->next;
        }
        return cur->val;
    }
    //增加头节点    
    void addAtHead(int val) {
        ListNode* newNode = new ListNode(val); //创建新的头节点
        newNode->next = dHead->next;  //将现有的链表接在新节点后面
        dHead->next = newNode; //将新的完整的节点再接回虚拟节点的后面 
        size++;  //长度+1
    }
    //增加尾节点
    void addAtTail(int val) {
        ListNode* newNode = new ListNode(val);
        ListNode* cur = dHead;
        while(cur->next != nullptr)
        {      //先要找到最后一个节点位置
            cur = cur->next;
        }
        cur->next = newNode;
        size++;
    }
    //在链表中第index节点前加元素。
    //index为链表长度，就加在尾巴
    //index大于长度，不加
    //index小于长度，加在头
    void addAtIndex(int index, int val) {
        //小于长度
        if(index > size){ //因为等于的时候是天价在尾短，所以此处大于就好
            return;
        }
        ListNode* newNode = new ListNode(val);
        ListNode* cur = dHead;  //注意，这里与上面获取index节点值的区别，上面是直接找到index位置，这里找到index前一个位置
        while(index--){
            cur = cur->next;
        }
        newNode->next = cur->next; //先把index位置开始的链表接在新节点上
        cur->next = newNode;  //再把新节点接在截断位置
        size++;
    }
    //删除index位置的节点
    void deleteAtIndex(int index) {
        if(index >= size || index < 0){return;}
        ListNode* cur = dHead;
        while(index--){
            cur = cur->next;
        }
        ListNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        size--;

    }
private:
    int size;
    ListNode* dHead;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

206. 反转链表

题目：

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        ListNode* tmp;  //保存下一个节点, 否则第一次反转完，cur的后一个节点是空节点
        while(cur != nullptr){
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

24. 两两交换链表中的节点

题目：

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dhead = new ListNode(0); //创建虚拟节点
        dhead->next = head; //将链表接在虚拟节点后面
        ListNode* cur=dhead;
        //相当于3个节点为一组，进行操作交换
        while(cur->next != nullptr && cur->next->next != nullptr){
            ListNode* tmp = cur->next;
            ListNode* tmp1 = cur->next->next->next;

            cur->next = cur->next->next;
            cur->next->next = tmp;
            cur->next->next->next = tmp1;
            cur = cur->next->next;  //往后移动两位
        }
        return  dhead->next;

    }
};

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

思想：双指针法，让fast指针先前进n+1位，再让两个指针一起走，知道fast为空的时候，slow正好指向要删除元素的前一个位置。然后进行删除操作即可。
代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dhead = new ListNode(0);  //创建虚拟节点
        ListNode* slow = dhead;
        ListNode* fast = dhead;
        dhead->next = head;
        //先让fast走n+1步，这样fast到null的时候，slow指向要删除元素的前一个元素
        while(n-- && fast != nullptr){
            fast = fast->next;
        }
        fast = fast->next;
        //再同时走
        while(fast != nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* tmp=slow->next;
        slow->next = tmp->next;
        delete tmp;  //释放内存
        return dhead->next; 

    }
};

面试题 02.07. 链表相交

题目：

思路：首先确定是指针相同，而不是数值相同。再就是当找到一个指针相同的节点时，后面的节点也都是一样的。同理找到相同节点时，后面剩下的长度也是一样的。所以可以先以短的链表为基准，找到对齐位置（尾部对齐）。然后再对比找相同节点。

操作步骤：

• 先求两个链表的长度（为了确定哪个时长的，哪个是短的）
• 求出长度差L
• 在长链表中，将设置的指针向后移动L位（保证剩下的部分与短链表长度一致）
• 然后就可以遍历查找是否有相同节点了，如果有直接返回，等到链表为空还没找到，就返回空。

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* cur1 = headA;
        ListNode* cur2 = headB;
        int len1 = 0;
        int len2 = 0;
        //先求第一个链表长度
        while(cur1 != NULL){
            cur1 = cur1->next;
            len1 ++;
        }
        cur1 = headA;
        //再求第二个链表长度
        while(cur2 != NULL){
            cur2 = cur2->next;
            len2 ++;
        }
        cur2 = headB;

        //保证第一个链表是长的，第二个是短的
        if(len1 < len2){
            swap(len1,len2);
            swap(cur1,cur2);
        }
        //求长度差，为了让第一个链表移动到中间位置
        int L = len1- len2;
        //将长的链表移动到长度差的位置，因为指针相同，其后面的所有节点都要相同
        while(L--){
            cur1 = cur1->next;
        }
        //开始遍历
        while(cur1 != NULL){
            if(cur1 == cur2){
                return cur1;
            }
            cur1 = cur1->next;
            cur2 = cur2->next;
        }
        return NULL;
    }
};

142. 环形链表 II

题目：

思路：

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL)
        {
            //快指针移动两位，慢指针移动一位
            fast = fast->next->next;
            slow = slow->next;

            //快慢指针相遇位置
            if(fast == slow)
            {
                ListNode* cur1 = fast;
                ListNode* cur2 = head;
                //从头走到入环位置的节点数要和从相遇点走到入环位置的节点数相同
                while(cur1 != cur2)
                {
                    cur1 = cur1->next;
                    cur2 = cur2->next;
                }
                return cur2;
            }
        }
        return NULL;
    }
};