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

203.移除链表元素

题目：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

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

思路： 题目所给的链表的头节点有可能是要删除的结点，如果单独讨论要不要删除头结点，会让事情变得复杂。给头节点加一个虚拟头节点，那么原本的头节点与后面的节点的处理方式就是一样的了，题目要返回的新的头节点就是虚拟头节点的next节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode root=new ListNode(-1);
        root.next=head;

        ListNode pre=root,cur=head;
        while(cur!=null){
            if(cur.val==val){
                pre.next=cur.next;
            }else{
                pre=cur;
            }
            cur=cur.next;
        }

        return root.next;

    }
}

707.设计链表

题目：设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路：

1. 确定链表是单链表还是双链表，从而确定链表中节点的数据结构。
2. 增加length属性，记录当前链表的长度。
3. 根据题目的意思完成方法体的编程。

编程中遇到的问题：没有认真审题，胡乱猜测链表节点的下标是从1开始的,导致对于index和length的关系判断错误，造成程序运行结果出错。因此，要注意链表的边界条件。

class MyLinkedList {

    class Node{
        int val;
        Node next;

        Node(){}

        Node(int val){
            this.val=val;
            this.next=null;
        }

        Node(int val,Node next){
            this.val=val;
            this.next=next;
        }
    }

    private Node head;
    private int length;

    public MyLinkedList() {
        head=new Node(-1);
        length=0;
    }
    
    public int get(int index) {

        if(index>=length||index<0){
            return -1;
        }

        Node node=head.next;

        for(int i=0;i<index;i++){
            node=node.next;
        }

        return node.val;
    }
    
    public void addAtHead(int val) {
        Node node=new Node(val,head.next);
        head.next=node;
        length++;
    }
    
    public void addAtTail(int val) {
        Node node=head;

        while(node.next!=null){
            node=node.next;
        }

        node.next=new Node(val);
        length++;
    }
    
    public void addAtIndex(int index, int val) {

        if(index>length){
            return;
        }

        if(index<=0){
            addAtHead(val);
            return;
        }

        if(index==length){
            addAtTail(val);
            return;
        }

        Node pre=head;
        Node node=new Node(val);

        for(int i=0;i<index;i++){
            pre=pre.next;
        }

        node.next=pre.next;
        pre.next=node;

        length++;
    }
    
    public void deleteAtIndex(int index) {

        if(index>=length||index<0){
            return;
        }

        Node node=head.next;
        Node pre=head;

        for(int i=0;i<index;i++){
            pre=pre.next;
            node=node.next;
        }

        pre.next=node.next;

        length--;

    }
}

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

题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

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

思路：使用cur表示当前指向的节点，pre表示cur的前驱节点，当cur不是最后一个节点时，使用next保存cur的后继节点，然后令cur的next指向pre，再令pre指向cur，cur指向next，完成一次链表上的移动。当cur遍历到链表的最后一个节点时，直接令cur的next指向pre,cur作为链表反转后的头节点返回即可。

示意图如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {

        if(head==null||head.next==null){
            return head;
        }

        ListNode pre=head,cur=head.next,next;
        //head作为反转链表的最后一个节点，next指向null
        head.next=null;

        while(cur.next!=null){
            next=cur.next;

            cur.next=pre;
            pre=cur;
            cur=next;
        }

        cur.next=pre;

        return cur;
    }
}