代码随想录算法训练营day3 | leetcode203 移除链表元素 、leetcode707 设计链表、leetcode 206 反转链表

移除链表元素

题目链接：移除链表元素

这道题考的是有关于链表的基础操作，这道题对于我来说，难点就是head头结点等于要删除的值不知道如何处理，后来查阅资料就明白了应该把头结点向后面移，直到它不等于要删除的值。

无虚拟头结点的写法

/**
 * 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) {
        if(head==null)
        {
            return head;
        }  
       ListNode p;
     
       p=head;
    
       while(head!=null&&head.val==val)//头结点后移
       {
           head=head.next;
           
       }
       while(p!=null&&p.next!=null)
       {
           if(p.next.val==val)//要删除某个节点，就要知道要删除节点的前一个节点
           {
               p.next=p.next.next;
           }
           else{
               p=p.next;
           }
       }
     
      return head;
    }
}

 有虚拟头结点的写法

/**
 * 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 viu=new ListNode(val-1);//创建虚拟头结点，便于寻找目标节点的前一个位置
        viu.next=head;
        if(head==null)
        {
            return head;
        }
       ListNode p=viu;
       while(p.next!=null)
       {
           if(p.next.val==val)
           {
               p.next=p.next.next;
           }
           else{
               p=p.next;
           }
       }
        return viu.next;
    }
}

设计链表

题目链接：设计链表

这道题考的是有关链表的设计和对于链表的理解。对于我来说这道题有两个难点：1是有关于链表的初始化不清楚；2是对于链表的下标和长度容易搞混

以下是单链表写法

class MyNode{
    MyNode next;//创建指向链表的下一个节点的值next
    int val;//指定链表的值
    public MyNode (int val){
        this.val=val;
    }//有参构造法，使val能传值进去
}

class MyLinkedList {
int size;//定义链表长度
MyNode head;//定义头结点
    public MyLinkedList() {
        size=0;//初始化长度
        head=new MyNode(0);//初始化头结点
    }
    //下标index是从0开始的，size是从1开始的，size=index+1
    public int get(int index) {
        if(index<0||index>=size)
        {
            return -1;
        }
        MyNode cur=head;
        for(int i=0;i<=index;i++)//i与index一样是从0开始，故i<=index
        {
            cur=cur.next;
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        if(index>size)
        {
            return;
        }
        if(index<0)//这里题目并未表明index<0时的情况，故index<0时index=0
        {
            index=0;
        }
        MyNode per=head;
        MyNode newadd=new MyNode(val);//创建一个用于插入的节点
        size++;
        for(int j=0;j<index;j++)
        {
            per=per.next;
        }
//这里只在前面插入是因为下标index是从0开始的，size是从1开始的，size=index+1
//所以index不等于size
        newadd.next=per.next;
        per.next=newadd;
    }
    //删除节点
    public void deleteAtIndex(int index) {
        if(index<0||index>=size)
        {
            return;
        }
        size--;
        MyNode perd=head;
        for(int k=0;k<index;k++)
        {
            perd=perd.next;
        }
        perd.next=perd.next.next;
    }
}

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

反转链表

题目链接：反转链表

这道题对于我来说是一位老熟人了，它的核心是创建一个空节点用于存放他们之间的关系转换

/**
 * 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) {
        ListNode r=null;//创建空节点
        ListNode p=head;
        ListNode q;
        while(p!=null)
        { 
            q=p.next;//注：将p的next提前储存起来，不然在后面的循环就找不到下一次循环开始的位置
            p.next=r;
            r=p;
            p=q;

        }
        return r;
    }
}

总结： 对于此次的题目，我个人觉得还是有点难度的，这主要还是我对于链表的代码理解不够深刻和熟练；特别是那道创建链表的题，让我理解了好久才想清楚。