代码随想录 | 链表 203. 移除链表元素；707.设计链表； 206.反转链表

链表

链表的存储方式

链表中的节点在内存中可以不是连续分布，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理

链表的类型

• 单链表
• 双链表
• 循环链表

203. 移除链表元素

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

---

视频链接

乍一看这题挺简单的，在数据结构这门课中老师也反反复复的讲过怎么删除链表中的元素，但是真实上手之后，发现这里有问题，那里也有问题，在起初做这道题的时候，我想到使用一个虚拟头结点来进行操作，但是因为把虚拟头结点 和 头结点 搞混了，结果越想越复杂。

不使用虚拟头结点

不使用虚拟头节点需要注意以下几个问题：

• 不能直接对空指针进行操作（在任何时候都要注意）
• 对于头结点和非头结点的删除要分开处理

思路：对于头结点，在确认 head != null 和 head.next != null 之后，直接让 head = head.next 即可；对于非头结点，使用临时指针 cur(cur在最开始适应赋值为 cur = head) 指向要删除的链表节点的前一个节点，使得 cur.next = cur.next.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) {
        ListNode cur = null;
        while(head != null && head.val == val){//被删除节点是头节点的操作
            head = head.next;
        }
        cur = head;//要使用被删除节点的前一个节点
        while(cur != null && cur.next != null){
            if(cur.next.val == val){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
        }
        return head;

    }
}

使用虚拟头结点

使用虚拟头结点应注意的问题:

1、虚拟头结点应当进行实例化,它和链表中的头结点是有区别的：
	链表中的头结点在这里视为链表元素之一,是有具体赋值的;
	虚拟头结点是指向链表中头节点的。
2、注意不要直接操作空指针
3、返回的节点应当是虚拟节点所指向的下一个节点，因为原来的头结点可能已经被删除了

思路:设置一个虚拟头结点并对其进行实例化, 让虚拟头结点指向链表中的原始头结点, 声明一个临时指针, 令临时指针等于虚拟头结点, 然后进行迭代删除操作。
代码实现如下：

/**
 * 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) {
        ListNode dummyHead = new ListNode();//对虚拟头结点进行实例化
        dummyHead.next = head;//指向头结点方便对头结点进行操作
        ListNode cur = dummyHead;
        while(cur != null && cur.next != null){
            if(cur.next.val == val){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
        }
        return dummyHead.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 个节点。

---

代码实现如下：

class ListNode{
    int val;
    ListNode next;
    ListNode(){};
    ListNode(int val){
        this.val = val;
    }
}
class MyLinkedList {
    int size = 0;
    ListNode dummyHead;
    public MyLinkedList() {
        this.size = 0;
        dummyHead = new ListNode(0);
    }
    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode cur = dummyHead;
        if(index >= size || size < 0){
            return -1;
        }
        while(index-- >= 0){
            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 > size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        size++;
        ListNode cur = dummyHead;
        for(int i = 0; i< index; i++){
            cur = cur.next;
        }
        ListNode newNode = new ListNode(val);
        newNode.next = cur.next;
        cur.next = newNode;
    }
    
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        if (index == 0) {
            dummyHead = dummyHead.next;
	    return;
        }
        ListNode pred = dummyHead;
        for (int i = 0; i < index ; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;

    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

---

206. 反转链表

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

---

文章链接
刚开始思考这个题目时，想法容易被数组的反转给引过去，想着让链表中的值来回调换下，但是仔细想想这种做法对于单链表来说太过复杂。仔细思考链表的定义，其实只要把每个节点中间的链接调换下就可以了。由此便可得到解题的思路。
思路：定义三个node节点，right节点先行出发，temp节点在中间承接交换，left节点在后面接收穿个来的链接，如此循环往复，便可实现反转链表。
代码实现如下：

/**
 * 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 reverseList(ListNode head) {
        ListNode temp = null;
        ListNode pre = null;
        ListNode cur = head;
        boolean loopFlag = true;
        if(cur == null){
            return head;
        }
        while(loopFlag){
            temp = cur;
            cur = cur.next;
            temp.next = pre;
            pre = temp;
            if(cur == null){
                loopFlag = false;
                System.out.println(temp.val);
                System.out.println(pre.val);
            }
        }
        head = pre;
        return head;
    }
}

---

写在结尾

最近仔细思考了一下自己的工作方法,发现一些尚待改进的地方,总结了下,主要体现在

• 对于前两天做的算法题目要进行循环往复的复习、重做，重做时不必像第一次做的那么细致，重点对算法的思想进行回顾
• 提高时间的利用率，在写算法题目时，前30 min自己尝试解决，提倡使用画图的方式辅助思考，实在没搞出来，就去学习下其他人的想法思路，在复习时重点关注一下。
• 要善于改进工作流程，积极寻找合适恰当的方法来提高自己的工作效率，与我而言，主要体现在工作时应适当减少对于他人外界的关注，别人的事、别人的东西终归是别人的，真正消化吸收的东西才是自己的，不必攀比、不必“卷”，做好自己的事，其他一切问题终会化解。