算法训练day3-链表，203.移除链表元素、707.设计链表、206.反转链表

203.移除链表元素(easy)

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

思路：可以考虑不改变原链表而是通过创建一个新链表，在遍历原链表时，判断节点值，如果节点值不等于目标值，则为新链表创建一个新节点（val 等于该原节点的值）。对于新链表的头节点可考虑创建一个空节点，新的节点不断连接到这个空节点之后。最后返回这个空节点的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) {
        // 判空
        if (head ==null){
            return null;
        }
        // index用来遍历原链表
        ListNode index = head;
        // 空节点，作为新链表的虚拟头节点
        ListNode newhead = new ListNode();
        // 新链表的最新节点，借此不断加入新节点
        ListNode newNode = newhead;
        while(index!=null){
           if(index.val!=val){
              newNode.next = new ListNode(index.val);
              newNode = newNode.next;
           }
           index = index.next;
        }
        return newhead.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 个节点。

代码实现参考-java

// 双向链表
class MyLinkedList {
    private Node  head;
    private Node  tail;
    private int   size;

     // 节点类
     class Node{
         int val ;
         Node next;
         Node prev;
         public Node(){

         }
         public Node(int x){
             this.val = x;
         }
         
     }

    // 初始化链表
    public MyLinkedList() {
        this.head = new Node(0);
        this.tail = new Node(0);
        this.size = 0;
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int index) {
        // 检查索引
        if(index<0||index>=size){
            return -1;
        }

        // 双向链表取值时先判断index离那边更近，从近的取更快
        Node cur = head;
        if(index >= size/2){
            // 从tail开始遍历
            cur = tail;
            for(int i=0;i< size-index ;i++){
                cur = cur.prev;
            }
        }else{
           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 = 0;
        }
        if(index>size){
            return;
        }
        // 前置节点
        Node pre = head;
        for(int i=0;i<index;i++){
            pre  = pre.next;
        }
        Node newNode = new Node(val);
        newNode.next  = pre.next; // 新节点next指向目标节点
        pre.next.prev  = newNode; // 目标节点的prev指向新节点
        pre.next = newNode; // pre节点的next指向新节点
        newNode.prev = pre; // 新节点的prev指向pre节点
        size++;
    }
    
    public void deleteAtIndex(int index) {
        // 检查索引
        if(index<0||index>=size){
            return ;
        }
        // 继续找前置节点
        Node pre = head;
        for(int i=0;i<index;i++){
            pre = pre.next;
        }
        Node cur = pre.next;
        if(cur!=null){
            pre.next = cur.next;
            cur.next.prev =  pre;
            cur.next = null;
            cur.prev = null;
        }
        size--;

    }
}

206.反转链表

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

package org.DataStruct;

public class ReverseList {
    // 反转链表
    public ListNode reverseList01(ListNode head){
        if (head==null){
            return null;
        }
        ListNode pre = head;
        ListNode current = head.next;
        pre.next=null;
        while (current!=null){
            ListNode next = current.next; //保存当前节点的next指针
            current.next = pre; // 修改当前节点next指向前一个节点
            pre = current;  // pre后移
            current  = next; // current后移
        }
        return pre;
    }



    class ListNode{
        int val;
        ListNode next;
        ListNode(int x){
            val= x;
        }
    }
}