代码随想录算法训练营第三天|203.移除链表元素、707.设计链表、206.反转链表

203.移除链表元素

203. 移除链表元素 - 力扣（LeetCode）

思路：

1、创建虚拟头dummyhead，并创建temp指向dummyhead。

2、进入循环判断temp.next是否为空，为空表示链表到末尾。接下来判断temp.next.val == val，是则跳过temp.next所指的元素，指向temp.next.next的元素；不是则temp指向temp.next的元素。（图片展示过程）

3、循环结束，最后要记得返回dummyhead.next，因为dummyhead是在原链表删除元素后的结果，temp只是指向链表中的元素。然后dummyhead指向0，next才是想要的结果的头元素。

C#代码：

public class Solution {
    public ListNode RemoveElements(ListNode head, int val) {
        ListNode dummyhead = new ListNode(0,head);
        ListNode temp = dummyhead;
        
        while(temp.next != null){
            if(temp.next.val == val){
                temp.next = temp.next.next;
            }
            else{
                temp = temp.next;
            }
        }
        return dummyhead.next;
    }
}

707.设计链表

707. 设计链表 - 力扣（LeetCode）

思路：先写在链表中插入元素，也就是在目标节点之前加入，其实就是打断原有的指向，把指向切到temp就可以了，不过要注意temp要先指向head，再dummyhead指向temp，相反的话会丢失head元素。（删除其实也和插入链表一个道理，不过就是dummyhead和head互相指向就OK了。）

其他的就注意插入元素要判断index是不是小于0或者大于链表长度。

C#代码：

public class ListNode{
    public int val;
    public ListNode pre;
    public ListNode next;
    public ListNode (int val){
        this.val = val;
    }
}

public class MyLinkedList {

    ListNode head;
    ListNode tail;
    int count = 0;

    public MyLinkedList() {
        head = new ListNode(-1);
        tail = new ListNode(-2);
        head.next = tail;
        tail.pre = head;
    }
    
    public int Get(int index) {
        if(index < 0 || index >= count)return -1;
        ListNode temp = head;
        int n = 0;
        while(n <= index){
            temp = temp.next;
            n++;
        }
        return temp.val;
    }
    
    public void AddAtHead(int val) {
        ListNode dummyp = head;
        ListNode p = head.next;
        ListNode temp = new ListNode(val);
        temp.next = dummyp.next;
        temp.pre = p.pre;
        dummyp.next = temp;
        p.pre = temp;
        count++;
    }
    
    public void AddAtTail(int val) {
        ListNode dummyp = tail.pre;
        ListNode p = tail;
        ListNode temp = new ListNode(val);
        temp.next = dummyp.next;
        temp.pre = p.pre;
        dummyp.next = temp;
        p.pre = temp;
        count++;
    }
    
    public void AddAtIndex(int index, int val) {
        if(index < 0 || index > count)return;
        ListNode temp = head;
        int n = 0;
        while(n < index){
            temp = temp.next;
            n++;
        }
        ListNode dummyp = temp;
        ListNode p = temp.next;
        ListNode node = new ListNode(val);
        node.next = dummyp.next;
        node.pre = p.pre;
        dummyp.next = node;
        p.pre = node;
        count++;
    }
    
    public void DeleteAtIndex(int index) {
        if(index < 0 || index >= count)return;
        ListNode temp = head;
        int n = 0;
        while(n<=index){
            temp = temp.next;
            n++;
        }
        ListNode dummyp = temp.pre;
        ListNode p = temp.next;
        dummyp.next = p;
        p.pre = dummyp;
        count--;
    }
}

206.反转链表

206. 反转链表 - 力扣（LeetCode）

思路：

C#代码：

public class Solution {
    public ListNode ReverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode nex = null;
        while(cur != null){
            nex = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nex;
        }
        return pre;
    }
}

总结：链表删除元素和反转链表之前刷过，不是很难。设计链表这块想起来还是没那么清晰，而且刚开始看示例没意识到双向链表，想不出来，看答案看不出怎么加元素、删元素，花太多时间了。现在倒是能看懂每个类的运行过程了，不过之后还得二刷一遍。