链表(1)

目录

• 203移除链表元素
• 707设计链表
• 206反转链表
• 两两交换链表中的节点
• 19删除倒数第n个节点

203移除链表元素

用一个pre指针指向head之前，然后检测pre->next是否是目标元素
循环终止是pre->next为空

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode * ans=new ListNode(-1);
        ans->next=head;
        ListNode* pre=ans;
        while(pre->next!=nullptr)
        {
            if(pre->next->val==val)
            {
                pre->next=pre->next->next;
                continue;
            }
            pre=pre->next;
        }
        return ans->next;
    }
};

707设计链表

注意读题！！！！

class MyLinkedList {
public:
    MyLinkedList() {
        size=0;
        head=new ListNode(-1);
    }
    
    int get(int index) {
        if(index<0||index>=size)
        {
            return -1;
        }
        ListNode * ret=head;
        ret=ret->next;
        while(index--)
        {
            ret=ret->next;
        }
        return ret->val;
    }
    
    void addAtHead(int val) {
        ListNode* newNode=new ListNode(val);
        newNode->next=head->next;
        head->next=newNode;
        size++;
    }
    
    void addAtTail(int val) {
        ListNode * ret=head;
        ListNode * newNode=new ListNode(val);
        int index=size;
        while(index--)
        {
            ret=ret->next;
        }
        ret->next=newNode;
        size++;

    }
    
    void addAtIndex(int index, int val) {
        if(index==0)
        {
            addAtHead(val);
            return;
        }
        if(index==size){
            addAtTail(val);
            return;
        }
        if(index<0||index>=size)
        {
            return;
        }
        ListNode * pre=head;
        ListNode * newNode=new ListNode(val);
        while(index--)
        {
            pre=pre->next;
        }
        newNode->next=pre->next;
        pre->next=newNode;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index==0)
        {
            head=head->next;
            size--;
            return;
        }
        if(index<0||index>=size)
        {
            return;
        }
        ListNode * pre=head;
        while(index--)
        {
            pre=pre->next;
        }
        pre->next=pre->next->next;
        size--;
    }
private:
    ListNode* head;
    int size;
};

206反转链表

用pre指向head之前，cur指向head
cur指向pre，然后cur和pre整体后移，
循环终止是cur=nullptr

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;

    }
};

两两交换链表中的节点

比较简单

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* ans=new ListNode(-1);
        ans->next=head;
        ListNode* pre=ans;
        while(pre->next!=nullptr&&pre->next->next!=nullptr)
        {
            ListNode * first=pre->next;
            ListNode* second=pre->next->next;
            pre->next=second;
            first->next=second->next;
            second->next=first;
            pre=first;
        }
        return ans->next;
    }
};

19删除倒数第n个节点

/**
 * 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* slnA(ListNode* head, int n)
    {
        ListNode* dummy=new ListNode(-1);
        dummy->next=head;
        ListNode* pre=dummy;
        int len=0;
        while(pre->next!=nullptr)
        {
            pre=pre->next;
            len++;
        }
        int pos=len-n;
        pre=dummy;
        while(pos--)
        {
            pre=pre->next;
        }
        pre->next=pre->next->next;
        return dummy->next;
    }
    //单次扫描
    ListNode* slnB(ListNode* head, int n)
    {
        ListNode* dummy=new ListNode(-1);
        dummy->next=head;
        ListNode* slow=dummy,* fast=dummy;
        while(n--)
        {
            fast=fast->next;
        }
        while(fast->next!=nullptr)
        {
            fast=fast->next;
            slow=slow->next;
        }
        slow->next=slow->next->next;
        return dummy->next;
    }
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        return slnB(head,n);
    }
};