java链表-203移除链表元素|206.反转链表| 707.设计链表

背景：
最近做链表算法题，以前做过的题也忘记了，于是又总结了链表相关知识：
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
链表的入口节点称为链表的头结点也就是head。

链表的类型
双链表
单链表中的指针域只能指向节点的下一个节点。
双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。
双链表 既可以向前查询也可以向后查询。
如图所示：

链表的存储方式
数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。
链表是通过指针域的指针链接在内存中各个节点。
所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

链表的定义：

//链表定义； 
 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; }//构造函数
  }
  //创建链表
  ListNode cur = new ListNode(-1,head);//创建一个data为-1，且next指向head节点的链表

203移除链表元素
针对删除链表，一般是链表的next指向删除链表的下一个节点，所以一般需要两个节点处理代码：
本题采用有虚节点和无虚节点两种：
题目如下图：

 public ListNode removeElements(ListNode head, int val) {
        if(head==null){
            return head;
        }
        ListNode cur =head;
        ListNode dumyNode = new ListNode(-1);//虚节点创建，
        dumyNode.next=head;
        ListNode pre = dumyNode;
        while(cur!=null){
            if(cur.val == val){
                pre.next = cur.next;
            }else{
            pre = cur;
            }
            cur = cur.next;
        }
        return dumyNode.next;
    }
    //不用虚节点
     public ListNode removeElements(ListNode head, int val) {
        if(head==null){
            return head;
        }
        while(head !=null &&head.val == val){
            head = head.next;
        }
        ListNode pre =head;
        ListNode cur = head.next;//报错空指针，原因：当链表为{1，1，1}若一致head=head.next后为空链表，此时应返回
        while(cur!=null){
            if(cur.val == val){
                pre.next = cur.next;
            }else{
            pre = cur;
            }
            cur = cur.next;
        }
        return head;
    }
    //正确解法
     public ListNode removeElements(ListNode head, int val) {
         while(head !=null &&head.val == val){//优先处理该情况，避免空指针情况
            head = head.next;
        }
        if(head==null){
            return head;
        }       
        ListNode pre =head;
        ListNode cur = head.next;
        while(cur!=null){
            if(cur.val == val){
                pre.next = cur.next;
            }else{
            pre = cur;
            }
            cur = cur.next;
        }
        return head;
    }

206 反转链表
拿到这个题，本能反应是节点的next反向变化，有个细节需要注意，节点为空和一个节点的判断，注意空指针
题目如下：

代码如下：

 public ListNode reverseList(ListNode head) {
        if(head==null ||head!=null&&head.next==null){//空链表和一个节点的链表处理
            return head;
        }        
        ListNode pre = null;
        ListNode cur = head;
        ListNode aft = cur.next;//调试之前这里写在while循环中，会导致最后的cur是空指针null，导致最后结果不对
        while(cur!=null&&cur.next!=null){
            cur.next = pre;
            //下面pre,cur，aft每次变化依次向后
            pre = cur;
            cur = aft;
            aft=cur.next;
        }
        System.out.println(cur.val);
         cur.next = pre;
        return cur;
    }

707设计链表

代码如下:

//单链表
class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    //size存储链表元素的个数
    int size;
    //虚拟头结点
    ListNode head;

    //初始化链表
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }

    //获取第index个节点的数值，注意index是从0开始的，第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;
    }

    //在链表最前面插入一个节点，等价于在第0个元素前添加
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }

    //删除第index个节点
    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;
    }
}

//双链表
class ListNode{
    int val;
    ListNode next,prev;
    ListNode() {};
    ListNode(int val){
        this.val = val;
    }
}


class MyLinkedList {  

    //记录链表中元素的数量
    int size;
    //记录链表的虚拟头结点和尾结点
    ListNode head,tail;
    
    public MyLinkedList() {
        //初始化操作
        this.size = 0;
        this.head = new ListNode(0);
        this.tail = new ListNode(0);
        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
        head.next=tail;
        tail.prev=head;
    }
    
    public int get(int index) {
        //判断index是否有效
        if(index<0 || index>=size){
            return -1;
        }
        ListNode cur = this.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) {
        //等价于在第0个元素前添加
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        //等价于在最后一个元素(null)前添加
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        //index大于链表长度
        if(index>size){
            return;
        }
        //index小于0
        if(index<0){
            index = 0;
        }
        size++;
        //找到前驱
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        //新建结点
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;
        pre.next.prev = newNode;
        newNode.prev = pre;
        pre.next = newNode;
        
    }
    
    public void deleteAtIndex(int index) {
        //判断索引是否有效
        if(index<0 || index>=size){
            return;
        }
        //删除操作
        size--;
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        pre.next.next.prev = pre;
        pre.next = pre.next.next;
    }
}