day3-代码随想录算法训练营（19）-链表

今天的三道题都还行，其中设计链表的时候调试的比较久，另外两题都刷过。

203.移除链表元素

ListNode* removeElements(ListNode* head, int val) {
        //思路：创建一个头结点，然后使用两个指针对链表进行遍历，找到时删除，判断头尾节点情况
        //问题：再遍历到尾节点时没有把尾节点置为空指针，导致一直循环超时
        ListNode*newHead=new ListNode();
        newHead->next=head;
        ListNode*pre=newHead,*cur=head;
        while(cur!=nullptr)
        {
            if(cur->val==val)
            {
                if(cur->next!=nullptr)
                {
                    pre->next=cur->next;
                    cur->next=nullptr;
                    cur=pre->next;
                }
                else//尾节点
                {
                    pre->next=nullptr;
                    cur=nullptr;
                }
                    
                continue;
            }
            pre=cur;
            cur=cur->next;
        }
        return newHead->next;

    }

newHead的创建是考虑到需要移除的元素是head时的情况。

707.设计链表

class MyLinkedList {
    struct Node{
        int val;
        Node*next;
        Node(int _val)
        {
            val=_val;
            next=nullptr;
        }
        Node()
        {
            val=0;
            next=nullptr;
        }
    };
public:
//先设计单链表
    //需要一个指针指向头结点，一个指针指向尾节点，一个指针记录下标
    //思路：使用哈希表存储，键为节点下标，值为节点，使用一个变量记录节点的个数
    //问题：简单问题搞复杂
   
    int count=0;//
    Node*head=new Node();
    MyLinkedList() {
    }
    
    int get(int index) {//获取index下标的节点值
        
        if(index>=count)
            return -1;
        int mid=0;
        Node*p=head->next;
        while(p)
        {
            if(mid==index)
                break;
            mid++;
            p=p->next;
            // cout<val<val;
    }
    
    void addAtHead(int val) {//头插法
       Node*node=new Node(val);
       node->next=head->next;
       head->next=node;
       count++;
       cout<next==nullptr)
            {
                p->next=node;
                break;
            }
            p=p->next;
        }
        count++;
        cout<count)
            return;
        
        Node*node=new Node(val);
        Node*cur=head->next,*pre=head;
        int mid=0;
        if(count==index)
        {
            addAtTail(val);
            return;
        }
        while(cur)
        {
            if(mid==index)
            {
                node->next=cur;
                pre->next=node;
                break;
            }
            pre=cur;
            cur=cur->next;
            mid++;
        }
        count++;
    }
    
    void deleteAtIndex(int index) {//删除指定下标节点
        if(index>=count)
            return;
        // cout<next,*pre=head;
        int mid=0;
        while(cur)
        {
            if(mid==index)
            {
                pre->next=cur->next;
                cur=nullptr;
                break;
            }
            mid++;
            pre=cur;
            cur=cur->next;
        }
        count--;
    }
};

这一题本来想利用哈希表的查找特性，但是实现过程中越来越复杂，最后采取了暴力查找的方法

206.反转链表

class Solution {
public:
    ListNode* reverseList1(ListNode*node)
    {
        if(node==nullptr || node->next==nullptr)
            return node;
        ListNode*newHead=reverseList1(node->next);
        node->next->next=node;
        node->next=nullptr;
        return newHead;
    }
    ListNode* reverseList(ListNode* head) {
        //思路：递归翻转
        return reverseList1(head);
    }
};

这一题做过多次，比较熟悉