第二章 链表part01

203. 移除链表元素

思路：非常简单的链表操作题目，只需要维护好前后指针即可完成操作。
这里说一下虚拟头结点的重要性，当我们需要对一个链表进行从前向后的操作时，第一个节点会因为没有前置节点所以需要进行特殊处理，但如果创建一个虚拟头结点，那么就能让整个链表的节点操作统一化，因此创建一个虚拟头结点是十分有必要的。

/**
 * 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 q = head;
        ListNode vh = new ListNode(-1, head); //创造一个虚拟头结点，方便后续操作
        ListNode p = vh;
        while(q != null){
            if(q.val == val){
                p.next = q.next;
            }else{
                p = q;
            }
            q = q.next;
        }
        return vh.next;
    }
}

707. 设计链表

一套常规的设计类的题目，自己设计并实现一套类似LinkedList的API，总体来说难度不小，需要考虑的情况会很多。
主要围绕addIndex来展开一系列插入操作，取元素则只需要创建一个临时节点进行遍历即可。

//节点数据结构
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 MyLinkedList {
    ListNode head; //虚拟头结点
    int size;

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

    
    public int get(int index) {
        //如果index非法，返回-1
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.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;
        }
        size++;
        ListNode pre = head;
        for(int i = 0; i < index; i++){
            pre = pre.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pre.next;
        pre.next = toAdd;
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        size--;
        if(index == 0){
            head = head.next;
            return;
        }
        ListNode pred = head;
        for(int i = 0; i < index; i++){
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

206.反转链表

反转链表的全部节点，一开始我选取了pre、cur、nex三个指针直接指向链表上的三个节点。但这种做法的弊端就是必须保证节点数大于等于3个，而且在nex指针的处理上还会出现nex.next不存在的情况，所以这些情况都是要自己debug才能想象出来的。
相反代码随想录的代码就更加的简洁明了。

class Solution {
    public ListNode reverseList(ListNode head) {
    	// 当链表为空，或只有一个节点时直接返回
        if(head == null || head.next == null){
            return head;
        }
        // 当链表只有两个节点时进行特殊处理
        if(head.next.next == null){
            ListNode pre = head.next;
            head.next.next = head;
            head.next = null;
            return pre;
        }
        // 当链表节点大于等于三个时，进行常规操作
        ListNode pre = head;
        ListNode cur = head.next;
        ListNode nex = cur.next;
        //标识第一个节点
        boolean flag = true;
        while(cur != null){
            if(flag){
                pre.next = null; //特殊处理第一个节点，将其next置为null
                flag = false;
            }
            cur.next = pre;
            pre = cur;
            cur = nex;
            if(nex != null){ //当最后一个节点已经走到null，而没有next时，直接跳过
                nex = nex.next;
            }
        }
        return pre;

    }
}

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode tem = null;

        while(cur != null){
            tem = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tem;
            
        }
        return pre;
    }
}