力扣刷题——链表

力扣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) {
        ListNode * p =head;//遍历指针
        //清理掉第一个数据节点是val的情况
        while(p&&p->val==val){
            head=head->next;
            p=p->next;
        }
        //上面已经排除第一个是val，就可以直接判断第二个以及后面
        while(p&&p->next){
            if(p->next->val ==val){
                p->next= p->next->next;
            }
            else p=p->next;
        }
        return head;
    }
};

带头结点

istNode* removeElements(ListNode* head, int val){
         ListNode * dummy = new ListNode;//定义一个虚拟节点
         dummy->next=head;
         ListNode * p= dummy;
         while(p->next){
             if(p->next->val==val){
                 p->next=p->next->next;
             }
             else{
                 p=p->next;
             }
         }
         //不能返回head ，比如 [7,7,7,7] val=7
         return dummy->next;
     }

力扣707设计链表

class MyLinkedList {
public:
    int num;//节点数为0
    
    typedef struct LinkedList{
        int val;
        LinkedList *next;
    }LinkedList;
    LinkedList * head;
    MyLinkedList() {
        head = new LinkedList;
        head->next=NULL;
        num =0;
    }
    
    int get(int index) {
        //如果下标无效，则返回 -1
        if(index<0||index>=num){
            return -1;
        }
        LinkedList *p=head;
        int count=0;
        while(p->next&&count!=index){
            count++;
            p=p->next;
        }
        return p->next->val;
    }
    
    void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    void addAtTail(int val) {
        addAtIndex(num,val);
    }
    
    void addAtIndex(int index, int val) {
        //如果 index 不合法，该节点将 不会插 到链表中。
        if(index<0||index>num){
            return;
        }
        LinkedList *p=head;
        int count=0;
        while(p->next&&count!=index){
            count++;
            p=p->next;
        }
        //在p后面插入新节点
        LinkedList *newnode= new LinkedList;
        newnode->next= p->next;
        newnode->val=val;
        p->next=newnode;
        num++;
        return ;
    }
    
    void deleteAtIndex(int index) {
        if(index<0||index>=num){
            return;
        }
        LinkedList *p=head;
        int count=0;
        while(p->next&&count!=index){
            count++;
            p=p->next;
        }
        //删除p后面的
        p->next=p->next->next;
        num--;
        return ;

    }
};

/**
 * 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反转链表

 非递归图解

//非递归
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *p,*pre,*q;
        p=head;
        pre=NULL;
        while(p){
            q=p->next;
            p->next=pre;
            pre=p;
            p=q;
        }
        return pre;
    }
};
//递归
class Solution {
public:
    ListNode* reverse(ListNode* p,ListNode* pre){
        if(p==nullptr) return pre;
        ListNode *q =p->next;
        p->next=pre;
        return reverse(q,p);
    }
    ListNode* reverseList(ListNode* head) {
        ListNode* p=head,*pre=nullptr;
        return reverse(p,pre);
    }
};

递归是参照非递归改编的，自行体会

力扣24两两交换链表中的节点

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        //定义一个虚拟头节点
        ListNode* dummy =new ListNode;
        dummy->next=head;
        //定义P one two three 
        ListNode *p=dummy,*one,*two,*three;
        //只有one two都不为空 才有必要交换 否则没必要
        while(p&&p->next&&p->next->next){
            if(p&&p->next&&p->next->next){
                one =p->next;
                two =one->next;
                three =two->next;
            }
            p->next=two;
            two->next=one;
            one->next=three;
            p=one;
            
        }
        return dummy->next;//注意不要返回head
        
    }
};

力扣82删除重复值的节点

lass Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        //定义一个头节点
        ListNode *dummy =new ListNode;
        dummy->next=head;
        //定义遍历节点P
        ListNode * p=dummy;
        //至少两个结点才可能存在重复
        while(p->next&&p->next->next){
            //遇到两个相同的
            if(p->next->val==p->next->next->val){
                int x=p->next->val;//记录这个重复值
                //如果后面的和这个重复的相同，就删除
                while(p->next&&p->next->val==x)
                     p->next=p->next->next;
            }
            //没遇到相同的就处理后一个
            else{
                p=p->next;
            }
        }
        return dummy->next;
    }
};

力扣142环形链表

若有环，快慢指针为何一定能相遇？

快2慢1，速度差为1，相当于一个不动，另一个以速度为1来靠近

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
       ListNode* fast=head ,*slow=head ;
       while(fast&&fast->next){
           fast=fast->next->next;
           slow=slow->next;
           //有环，跳出循环
           if(slow==fast) break;
       }
       //如果链表无环，则返回 null
       if(fast==NULL||fast->next==NULL) return NULL;
       //有环，我们开始寻找环的起点,之前定义的fast和slow直接拿来用
       //这儿找环的起点其实没有用到所谓的快慢指针，只是为了免得再定义指针
       //一个指针指向起始点，另一个指向相遇点 
       slow=head;
       //两个人同时往后走，相遇的点就是环开始的点
       while(slow!=fast){
           slow=slow->next;
           fast=fast->next;
       }
       return slow;
    }
};