代码随想录算法训练营第三天 | 203. 移除元素、707.设计链表 、206.反转链表

文档讲解：代码随想录（https://www.programmercarl.com/）
依然是补打卡! 追呀！k！😭

• 203.移除元素

思路分析：
两种情况：删除头节点 、删除非头节点
法一：设置一个虚拟头节点，这样原链表的所有节点就都可以按照统一的方式进行移除了(单独写一段逻辑来处理移除头结点看起来会比较好)

public ListNode removeElements(ListNode head, int val) {
        //添加虚拟头节点
        //先判断头节点是否为空，空直接返回
        if (head == null) {
            return head;
        }
        //设置虚拟dummy节点
        ListNode dummy = new ListNode(-1, head);//值为-1，指向真正的头节点head
        // 用两个节点来完成删除操作
        ListNode pre = dummy;
        ListNode cur = head;
         //后面按照正常的删除操作就好
         while( cur != null) {
             if (cur.val == val) {
                 pre.next = cur.next;
             } else {
                 pre = cur;//pre即指向当前的cur
             }
             cur = cur.next;//cur往后走
         }
         return dummy.next;//虚拟节点的下一个节点才是头节点
    }

• 707.设计链表

思路：
链表操作的两种方式：

1. 直接使用原来的链表来进行操作。
2. 设置一个虚拟头结点再进行操作。
   该题的坑主要是，链表的下表从0开始

class MyLinkedList {
    //大小
    int size;
    // 虚拟头节点
    ListNode head;
    
    public MyLinkedList() {
        // 初始化
        size = 0;
        head = new ListNode(0); // 默认值为0
    }
    
    public int get(int index) {
        // 临界判断
        if(index < 0 || index >= size) {
            return -1;
        }
        ListNode curNode =  head;// 临时的节点,不直接操作头节点
        for (int i = 0; i <= index; i++) { // index从0开始，所以要多加1
             curNode = curNode.next; 
        }
        return curNode.val; //返回index对应的值

    }
    
    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; 
        }
        // 若小于0  则index就是插入到头节点的前面
        if (index < 0) {
            index = 0;
        }

        size++; // 链表长度+1
        ListNode newNode = new ListNode(val);// 新建新的节点 
        // 找到待插入节点的前一个节点
        ListNode curNode = head;
        for (int i = 0; i < index; i++) {// 临时头节点，移动头节点 注意index 
            curNode = curNode.next;
        }
        // 新增节点操作
        newNode.next = curNode.next; // 指向当前节点的下一个节点
        curNode.next = newNode; // 改变当前节点的的指向为新增的
    }
    
    public void deleteAtIndex(int index) {
        // 临界判断
        if (index < 0 || index >= size) {
            return;
        }
        size--;

        // 找到要删除节点的前一个节点 定义一个临时头节点
        ListNode curNode = head;
        for (int i = 0; i < index; i++) {
            curNode = curNode.next; 
        }
        // 删除节点 改变指向即可
        curNode.next = curNode.next.next;
    }
}
/*
class ListNode {
    int val;
    ListNode next;
    ListNode() {};
    ListNode(int val) {
        this.val = val;
    }
    ListNode(int val, ListNode node) {
        this.val = val;
        this.next = node;
    }
}
*/

• 206.反转链表

思路：

• 双指针 （掌握）
• 递归
• 如果再定义一个新的链表，实现链表元素的反转，其实这是对内存空间的浪费
• 只需要改变链表next指针的指向，直接将链表反转

class Solution {
    public ListNode reverseList(ListNode head) {
        // 定义节点
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = null;

        while(cur != null) {
            temp = cur.next;// 先保存cur的下一个节点
            cur.next = pre; // 改变cur的指向
            pre = cur; // 上一个指针往后移
            cur = temp; // 当前cur往后移
        }
        return pre;
    }
}

简单总结：自己对链表的操作还不是很熟悉，虽然跟着思路下来能懂，也能够理解，但是过段时间就会忘了，还需要多多思考和练习。