代码随想录-Day03-LetCode|203-移除链表元素|707-设计链表|206-反转链表

203. 移除链表元素

        思路一：直接删除，普通节点删除的方式就是上一个节点的next等于当前节点的next，但是head节点没有上一个节点，所以需要单独进行删除，直至头节点不再是待删除元素。后续元素就可以按照规律进行删除。

class Solution {
    public ListNode removeElements(ListNode head, int val) {
       //头节点非空，并且头节点的值符合条件
        while(head!=null&&head.val==val){
            head=head.next;//删除头节点，这时候后续节点覆盖头节点，此时后续节点成为新的头节点
        }
        ListNode cur=head;//采用临时指针遍历链表，因为后续需要返回头节点
        while(cur!=null&&cur.next!=null){
            if(cur.next.val==val){
                cur.next=cur.next.next;//删除指定元素，此时临时指针指向未改变
            }else{
                cur=cur.next;//如果元素不是待删除目标，cur指针向前移动
            }
        }
        return head;

    }
}

        思路二：使用虚拟头节点，为了统一节点删除的规律，后续和上述删除方案相同

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummynode=new ListNode(-1);
        dummynode.next=head;//虚拟头节点
        ListNode cur=dummynode;
        while(cur.next!=null){
            if(cur.next.val==val){
                cur.next=cur.next.next;
            }else{
                cur=cur.next;
            }
            
        }
        return dummynode.next;

    }
}

707. 设计链表

        设计单链表，包括基本的增删改查，以及根据索引获取对应链表的值，其中设计需要注意的是，要确定链表的起始索引是0还是1，人为规定好

public class MyLinkedList {

    int size;
    ListNode head;
    public MyLinkedList() {
        this.size=0;
        this.head=new ListNode(0);
    }

    public int get(int index) {
        if(index<0||index>=size){
            return -1;
        }
        ListNode cur=head;
        for (int i = 0; i <= index; i++) {
            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<0||index>size){
            return ;
        }
        //0 1 2 3
        //1 2 3 4
        ListNode cur=head;
        for (int i = 0; i < index; i++) {
            cur=cur.next;
        }
        ListNode inser=new ListNode(val);
        inser.next=cur.next;
        cur.next=inser;
        size++;
    }

    public void deleteAtIndex(int index) {
        if(index<0||index>=size){
            return;
        }
        ListNode cur=head;
        for (int i = 0; i < index; i++) {
            cur=cur.next;
        }
        cur.next=cur.next.next;
        size--;
    }
}
class ListNode {
    int val;
    ListNode next;
    public ListNode(int val) {
        this.val= val;
    }
}

206. 反转链表

        思路：原本链表       1->2->3->4

                  反转之后        1<-2<-3<-4

                反转链表其实可以对链表的指向直接进行反转，最后返回尾节点，也就是反转之后的头结点。

class Solution {
    public ListNode reverseList(ListNode head) {
         ListNode tail=null;
        ListNode cur=head;//用来遍历当前节点
        ListNode nexts=null;//存储中间需要临时存储的节点
        while (cur!=null){
            //保存下一个节点
            nexts=cur.next;
            //反转cur的指向
            cur.next=tail;
            //尾指针向前移动
            tail=cur;
            //将下一个节点付给cur继续遍历
            cur=nexts;
        }
        return tail;//当值的尾指针移动至最前
    }
}

Write The Code！        Change The World！

                                                                                                        By        三条直线围墙！