链表部分：删除，设计，翻转

代码随想录算法训练营第3天 | 链表部分:203. 移除链表元素，707. 设计链表 ，206. 反转链表

链表部分

链表与数组的区别：
数组采用顺序存储，链表采用链式存储

首先对链表进行描述：通过指针将多个节点连接起来，包括头节点和后续节点，节点包含数据域和指针域
写一下链表的结构代码

public class ListNode{
	public int val;//节点的值
	public ListNode next;//节点的后继节点
	//无参构造函数忘记写了
	public ListNode(){}
	public ListNode(int val){
		this.val=val;
	}
	public ListNode(int val,ListNode next){
		this.val=val;
		this.next=next;
	}

203. 移除链表元素

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

这个题目需要注意的情况是：

1. 不能对当前节点指向的节点进行数据域的判断，因为如果这样的话，没办法表示它的前一个节点，这样就链表就连不起来了，需要用指针指向的下一个节点来表示当前节点，那样的话，如果当前节点被删除的话，那个指针指向的下一个节点就是当前节点的后面一个节点
2. 采用虚拟头节点的话可能会更方便一点，因为如果没有虚拟头节点的话，需要对头节点进行单独的判断，因为当头节点的值刚好是val时，需要对头节点进行更新，这个单独的处理就和后面非头节点的值为val时的处理不一样，虚拟头节点的出现使得无论是否为头节点，处理方式都是一致的

 public ListNode removeElements(ListNode head, int val) {
     ListNode dummyNode=new ListNode();
     ListNode pre=new ListNode();
     dummyNode.next=head;
     pre=dummyNode;
     while(pre.next!=null){
         if(pre.next.val==val){
             pre.next=pre.next.next;
         }else{
             pre=pre.next;
         }
     }
     return dummyNode.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 个节点。

这个题目的话，每次看见都会有点害怕，而且这边我好像不会debug,今天来试一试
写的过程中遇到的问题：MyListNode这个类中我需要写哪些变量，虚拟头节点要不要作为变量出现，还需要写别的变量吗
这边真的遇到了很多问题：debug一点点的调试，花了两个小时跳出来，哭了
感觉最主要的问题就是对于节点进行插入和删除之后，没有更新链表，导致
出现head一直是空指针的状态，让人头大，还有一个需要考虑的点是当索引值大于链表的长度的时候，此时直接返回，当链表为空，但是想要往链表头节点之外的位置进行插入的话，也是直接返回的，因为这种操作是错误的，节点的前面不可能存在空节点

总结：注意对头节点进行更新，注意考虑一些不能够进行的操作

class MyLinkedList {
    public ListNode head;
    public MyLinkedList() {
    }
    public MyLinkedList(ListNode head){
        this.head=head;
    }
    
    public int get(int index) {
        ListNode cur=new ListNode();
        ListNode dummyNode=new ListNode();
        dummyNode.next=head;
        cur=dummyNode;
        while(index>=0 && cur.next!=null){
            cur=cur.next;
            index--;
        }
         if(cur.next==null && index>=0){
            return -1;//这里表示链表的长度小于等待查找的index
        }
        //还有另外一种情况 0位置上没插入，直接在1位置上插入
        //这种不能插入成功
        
        return cur.val;
    }
    //在头部和尾部添加元素，其实就是在index为0或者遍历到最后的时候进行添加
    //所以先实现addAtIndex方法的话，可以把他应用在另外的方法中
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        ListNode dummyNode=new ListNode();
        ListNode pre=new ListNode();
        pre=dummyNode;
        dummyNode.next=head;
      while(pre.next!=null){
          pre=pre.next;
      }
      ListNode insertNode=new ListNode(val);
      insertNode.next=null;
      pre.next=insertNode;
      head=dummyNode.next;
    }
    //先实现的方法
    public void addAtIndex(int index, int val) {
        ListNode dummyNode=new ListNode();
        ListNode pre=new ListNode();
        dummyNode.next=head;
        pre=dummyNode;
        ListNode insertNode=new ListNode(val);
        if(index==0){
           insertNode.next=head;
            dummyNode.next=insertNode;
            head=dummyNode.next;
            return;
        }
        if(index>0 && dummyNode.next==null){
            return;
        }
       while(index>0 && pre.next!=null){
           pre=pre.next;
           index--;
       }
        insertNode.next=pre.next;
        pre.next=insertNode;
        head=dummyNode.next;
    }
    
    public void deleteAtIndex(int index) {
        ListNode pre=new ListNode();
        ListNode dummyNode=new ListNode();
        dummyNode.next=head;
        pre=dummyNode;
        if(index==0){
            dummyNode.next=dummyNode.next.next;
             head=dummyNode.next;
        }
        while(index>0 && pre.next!=null){
            pre=pre.next;
            index--;
        }
        if(pre.next==null){
            return;
        }
        if(pre.next.next==null){
           pre.next=null;
        }else{
             pre.next=pre.next.next;
        }
       
    }
}
class ListNode{
    public int val;
    public ListNode next;
    public ListNode(){};
    public ListNode(int val){
        this.val=val;
    }
     public ListNode(int val,ListNode next){
        this.val=val;
        this.next=next;
    }
}

206. 反转链表

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

感觉自己欠缺的部分在于：
两行代码之间的区别：创建一个值为null的节点和创建一个节点值为0的节点，无参构造器默认创建的节点值为0，上一个题都没意识到这个错误
ListNode pre=null;
ListNode pre=new ListNode();

思路：

1. 需要有个变量将后面还没翻转的链表保存
2. 将当前节点指针指向的位置进行转向
3. 最后更新翻转后的方向的节点

 ListNode dummyNode=new ListNode();
        ListNode pre=null;
        ListNode cur=new ListNode();
        dummyNode.next=head;
        ListNode temp=new ListNode();
        temp=head;
        while(temp!=null){
            cur=temp;
            temp=cur.next;
            cur.next=pre;
            pre=cur;
        }
        return pre;

总结：数组部分的总结还是没有看，一天跟个陀螺一样转，等我把周一的组会开完回来补；还有java中变量的声明 定义 初始化这一部分的知识点很迷惑需要整理；回去看这三个题的答案，重点看头节点是如何进行更新的