DAY3 链表part01

 

 

今日任务

●  链表理论基础

●  203.移除链表元素

●  707.设计链表

●  206.反转链表

链表理论基础

文章链接：https://programmercarl.com/%E9%93%BE%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

 1、循环链表用于解决约瑟夫环的问题

2、自定义链表结点的结构体

struct LinkNode
{
    int val;
    LinkNode* next;
    LinkNode():val(0),next(NULL) {}//初始化函数1；
    LinkNode(int x):val(x),next(NULL) {}//初始化函数2;
    LinkNode(int x,LinkNode *next):val(0),next(next) {}//初始化函数3；
}//自定义结构体时自选

LinkNode *head= new Linknode(x);

3、若使用C++默认的初始化函数，则初始化不能赋值

LinkNode *head= new Linknode();//即初始化函数1

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* dummy=new ListNode(0);
            dummy->next=head;
            ListNode*p=dummy;
            while(p->next!=NULL)
            {
                if(p->next->val==val) 
                {
                    ListNode* q=p->next;
                    p->next=p->next->next;
                    delete(q);//注意释放
                }
                else p=p->next;
            }
            head=dummy->next;
            return head;
    }
};

重点掌握虚拟头节点dummy的用法

题目链接/文章讲解/视频讲解：：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html

 

707.设计链表

class MyLinkedList {
public:
    struct LinkNode
    {
        int val;
        LinkNode* next;
        LinkNode(int x):val(x),next(NULL){};
    };
    MyLinkedList() {
        dummy=new LinkNode(0);
        cnt=0;
    }//掌握类的语法
    
    int get(int index) {
        if(index<0||index>=cnt) return -1;
        else
        {
            LinkNode*p=dummy->next;
            while(index--)
            {
                p=p->next;
            }//p定位到下标为index的位置
            return p->val;
        }
    }
    
    void addAtHead(int val) {
        LinkNode*newNode=new LinkNode(val);
        newNode->next=dummy->next;
        dummy->next=newNode;
        cnt++;
    }
    
    void addAtTail(int val) {
        LinkNode*newNode=new LinkNode(val);
        LinkNode*p=dummy;
        while(p->next!=NULL) p=p->next;
        p->next=newNode;
        cnt++;
    }
    
    void addAtIndex(int index, int val) {
        if(index<0||index>cnt) return;
        else if(index==cnt) 
        {
            addAtTail(val);
        }
        else if(index==0) addAtHead(val);
        else 
        {
            //定位到下标为index的结点前一个结点52             LinkNode*p=dummy;
            while(index--)
            {
                p=p->next;
            }
            LinkNode* newNode=new LinkNode(val);
            newNode->next=p->next;
            p->next=newNode;
            cnt++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index<0||index>=cnt) return ;
        else{
            LinkNode*p=dummy;
            while(index--)
            p=p->next;//p指向下标为index的结点前一个结点

            LinkNode*q=p->next;
            p->next=p->next->next;
            delete(q);
            cnt--;
        }
    }
    private:
    LinkNode*dummy=new LinkNode(0);
    int cnt;//定义全局变量
};

/**
 * 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);
 */

 

题目链接/文章讲解/视频讲解：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html

 

206.反转链表

思路：

 

解法一：双指针法

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;
    }
};

 

解法二：递归 还是一如既往的难以理解

/**
 * 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* reverse(ListNode* pre,ListNode*cur) {
      if(cur==NULL) return pre;
      ListNode*p=cur->next;
      cur->next=pre;
      return reverse(cur,p);
    }//递归函数，注意返回值

    ListNode* reverseList(ListNode*head)
    {
        return reverse(NULL,head);
    }//调用递归的函数
};

题目链接/文章讲解/视频讲解：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html

 

总结：

链表的定义；链表的基本操作；链表反转的两种方法