算法训练营day3

总结

输出一个链表的头节点head，在力扣中相当于把整个链表输出（力扣有这个相关的操作）；定义的cur就类似于数组中的i；

链表删去某个头节点时，先用t存head，然后操作head=head->next，最后删去t，中间节点同理；

取head->val前，需要先判断head!=NULL，中间节点同理；

设计链表的第一步就是定义一个节点的结构体，包括val,next，以及一个构造函数（值为val，next为nullptr）；

size可以用来简化代码，记录链表中节点的个数，这样遍历的时候，只要index在0-size-1，就一定没有空的；

删除第index个节点，只需要遍历到第index-1个节点，让前一节点的next指向index节点的后一个节点即可；

获取第index个节点数值

1.如果是不在0-size-1之间，return;

2.定义一个cur去遍历index次；

3.返回cur->val;

int get(int index) {
    if (index >= _size || index < 0) {
        return -1;
    }
    LinkedNode* cur = _dummyHead->next;//dummyHead是虚拟头，dummyHead->next是头节点
    while(index--){ // 如果--index 就会陷入死循环
        cur = cur->next;
    }
    return cur->val;
}

在链表最前面插入一个节点

1.new一个节点，用节点构造体的构造函数；

2.节点的next为虚拟头的next(之前的头结点);

3.虚拟头的next为节点；

4.链表节点数++；

void addAtHead(int val) {
    LinkedNode* newNode = new LinkedNode(val);
    newNode->next = _dummyHead->next;
    _dummyHead->next = newNode;
    _size++;
}

在链表最后面插入一个节点

1.new一个节点；

2.定义cur指针指向头结点；

3.一直往后遍历直到cur->next==NULL

4.cur->next赋为新new的那个节点；

5.链表节点数++；

void addAtTail(int val) {
    LinkedNode* newNode = new LinkedNode(val);
    LinkedNode* cur = _dummyHead;
    while(cur->next != nullptr){
        cur = cur->next;
    }
    cur->next = newNode;
    _size++;
}

删除第index个节点

1.判断index是否出界；

2.定义cur指针指向头节点；

3.往后遍历index，while(index–);

4.删除cur->next这个节点；

5.节点数–；

打印链表

1.定义cur指针指向头节点；

2.只要next不为空，就输出next的val值，更新cur位置；

void printLinkedList() {
    LinkedNode* cur = _dummyHead;
    while (cur->next != nullptr) {
        cout << cur->next->val << " ";
        cur = cur->next;
    }
    cout << endl;
}

203.移除链表元素

写了两个方法，一种是原链表直接区分头节点，另一种是虚拟头节点
注意操作完之后delete节点；
用虚拟头结点方法时，返回的是next；

//原链表直接操作
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head!=NULL&&head->val==val){
            ListNode *t=head;
            head=head->next;
            delete t;
        } 
        
        ListNode *cur=head;
        while(cur!=NULL&&cur->next!=NULL){
            if(cur->next->val==val){
                ListNode *t=cur->next;
                cur->next=cur->next->next;
                delete t;
            }
            else cur=cur->next;
        }

        return head;
    }
};

//虚拟头指针方法
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode *dummyHead=new ListNode(0);
        dummyHead ->next=head;

        ListNode *cur=dummyHead;
        while(cur!=NULL&&cur->next!=NULL){
            if(cur->next->val==val){
                ListNode *t=cur->next;
                cur->next=cur->next->next;
                delete t;
            }
            else cur=cur->next;
        }

        return dummyHead->next;
    }
};

707.设计链表

class MyLinkedList {
public:
    struct LinkedNode{
        int val;
        LinkedNode *next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    MyLinkedList() {
        dummyHead=new LinkedNode(0);
        size=0;
    }
    
    int get(int index) {
        if(index>=size||index<0) return -1;

        LinkedNode *cur=dummyHead->next;
        for(int i=0;i<index;i++){
            cur=cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode *idx=new LinkedNode(val);
        idx->next=dummyHead->next;
        dummyHead->next=idx;
        size++;
    }
    
    void addAtTail(int val) {
        LinkedNode *idx=new LinkedNode(val);

        LinkedNode *cur=dummyHead;
        while(cur->next!=nullptr){
            cur=cur->next;
        }
        cur->next=idx;
        size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>size) return;
        if(index<0) index=0;
        
        LinkedNode *idx=new LinkedNode(val);
        LinkedNode *cur=dummyHead;
        for(int i=0;i<index;i++){
            cur=cur->next;
        }
        idx->next=cur->next;
        cur->next=idx;
        size++;
    }
    
    void deleteAtIndex(int index) {
        if(index<0||index>=size) return;
        
        LinkedNode *cur=dummyHead;
        for(int i=0;i<index;i++){
            cur=cur->next;
        }
        LinkedNode *t=cur->next;
        cur->next=cur->next->next;
        delete t;
        size--;
    }
private:
    int size;
    LinkedNode*dummyHead;
};

206.反转指针

两种方法，双指针and递归，递归的思路跟双指针一样；

双指针思路

1.首先搞清楚初始化，pre为NULL，cur=head;
2.终点是cur指向NULL时，故while(cur)即可；
3.操作并后移即可，注意顺序；

class Solution {
public:
    ListNode* reverse(ListNode *cur,ListNode *pre){
        if(cur==NULL){
            return pre;
        }
        ListNode *t=cur->next;
        cur->next=pre;
        return reverse(t,cur);
    }
    ListNode* reverseList(ListNode* head) {
        return reverse(head,NULL);
    }
};

递归思路

1.首先考虑递归边界， cur为NULL时返回pre；
2.递归参数就是cur跟pre；
3.操作，跟双指针一样；

class Solution {
public:
    ListNode* reverse(ListNode *cur,ListNode *pre){
        if(cur==NULL){
            return pre;
        }
        ListNode *t=cur->next;
        cur->next=pre;
        return reverse(t,cur);
    }
    ListNode* reverseList(ListNode* head) {
        return reverse(head,NULL);
    }
};