小白视角刷leetcode （203. 移除链表元素、707. 设计链表、206. 反转链表）

203. 移除链表元素

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

思路：

        创建指向head的虚拟头结点，创建cur指针指向head，用cur遍历链表

        2.如果遇到了目标值，则用pre跳过目标值指向cur.next，如果不是目标值则分别向后移动

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1,head);
        ListNode pre = dummy;
        ListNode cur = head;
 
        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next;
                cur = cur.next;
            }else {
                pre = cur;
                cur = cur.next;
            }
            
        }
        return dummy.next;    
    }
}

707. 设计链表

---

你可以选择使用单链表或者双链表，设计并实现自己的链表。
​
单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
​
如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
​
实现 MyLinkedList 类：
​

MyLinkedList() 初始化 MyLinkedList 对象。

int get(int index) 获取链表中下标为 index 
的节点的值。如果下标无效，则返回 -1 。

void addAtHead(int val) 将一个值为 val 的节点
插入到链表中第一个元素之前。在插入完成后，新节点会
成为链表的第一个节点。

void addAtTail(int val) 将一个值为 val 的节
点追加到链表中作为链表的最后一个元素。

void addAtIndex(int index, int val) 将一个值
为 val 的节点插入到链表中下标为 index 的节点之前。
如果 index 等于链表的长度，那么该节点会被追加到链
表的末尾。如果 index 比长度更大，该节点将 不会插入 
到链表中。

void deleteAtIndex(int index) 如果下标有效，则删
除链表中下标为 index 的节点

note：

class MyLinkedList {
   
    int size;
    ListNode head;
 
    ListNode cur;
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);//head为虚拟头结点
    }
    
    public int get(int index) {
        if(index >= size || index < 0 ) return -1;//不要落下等号
        ListNode cur = head;    
        for(int i = 0 ; i <= index ; i++){//因为这道题的head是虚拟头节点占用一个位置，所以要小于等于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 || index < 0) return ;
        size++;
        ListNode toAdd = new ListNode(val);//新加入的值要new一个新节点
        cur = head;//head为虚拟头结点
        if(index == 0){
            toAdd.next = cur;//如果插入位置下标为0，即在头结点前插入，让新链表指向头结点
​
        }
        for(int i = 0 ; i < index ;i++){//因为cur指向的是虚拟头结点，因此i<index可以找到插入位置index的前驱节点
            cur = cur.next;
        }
            toAdd.next = cur.next;
            cur.next = toAdd;
    }
    
    public void deleteAtIndex(int index) {
        if(index >= size || index < 0) return ;
        size --;
        ListNode pre = head;
        for(int i = 0 ; i < index ; i++){
            pre = pre.next;
        }
        pre.next=pre.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);
 */

206. 反转链表

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

思路：

        两个指针负责转向，一个临时指针保存转向前cur的next

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