零基础代码随想录【Day3】|| 203.移除链表元素 , 707.设计链表 , 206.反转链表

目录

DAY3

 链表理论基础

 

203.移除链表元素  

解题思路&代码

方法1：用原来的链表操作

方法2：设置一个虚拟头结点

 707.设计链表  

解题思路&代码

206.反转链表 

解题思路&代码

方法1：双指针

方法2：递归

---

DAY3

 链表理论基础

建议：了解一下链接基础，以及链表和数组的区别 

文章链接：代码随想录

 

203.移除链表元素  

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

建议： 本题最关键是要理解 虚拟头结点的使用技巧，这个对链表题目很重要。

题目链接/文章讲解/视频讲解：：代码随想录

解题思路&代码

方法1：用原来的链表操作

思路：对于首个头节点的移除，直接往后移一个，就断开删除了，对于其他节点，该指针跳过下一个节点，指向下下个节点，下一节点就从链表中删除了

要点：掌握链表的创建，LeetCode自动创建，但面试的时候得自己创建

/**
 * 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) {
        while(head != null && head.val == val) {
            head = head.next;//将首头节点往后移一位，以此达到删除，此处是要改变head的值的
        }
        if (head == null) {
            return head;//如果第一个链表节点是null，就不对节点做操作，直接返回
        }//此时 head.val != val
        ListNode pre = head;
        ListNode cur = head.next;//因为过程中要反复用到pre，next所以单独创建一个变量，因为head值不能改，不然后续返回不了
        while(cur != null ) {
            if(cur.val == val) {
                pre.next = cur.next; //该指针跳过下一个节点指向下下个节点
            } else{
                 pre = cur; //不是目标值，移动到下一个节点，所以需要定义单独的pre变量
            }
            cur = cur.next;//移动到下一个节点，开始下一轮的筛选，所以需要定义单独的cur变量
        }
        return head;
    }
}

方法2：设置一个虚拟头结点

思路：这样就不存在首头节点的问题了，可以用同样的规则删除所有节点

/**
 * 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 head;
        }
        // 因为删除可能涉及到头节点，所以设置dummy节点，统一操作
        ListNode dummy = new ListNode(-1, head);//创建虚拟头节点
        ListNode pre = dummy;
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == val) {
                pre.next = cur.next;//该指针跳过下一个节点指向下下个节点
            } else {
                pre = cur;//pre这个是遍历，往下推进，pre.next改变指针指向的位置
            }
            cur = cur.next;
        }
        return dummy.next;//为什么不用原来的首head，因为有可能被删除了，但虚拟节点的下一个节点一定是当下的首head
    }
}

 707.设计链表  

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

• MyLinkedList() 初始化 MyLinkedList 对象。
• int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
• void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
• void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
• void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
• void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

建议： 这是一道考察 链表综合操作的题目，不算容易，可以练一练 使用虚拟头结点

题目链接/文章讲解/视频讲解：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html

解题思路&代码

方法1：单链表

思路：

get(index) 实现过程，先判断有效性，再通过循环来找到对应的节点的值。

addAtIndex(index, val)实现过程：

1. 找前驱节点pred；
2. 创建新节点toAdd；
3. 将toAdd.next的设置为pred.next, 将pred.next设置为toAdd(注意： 这里的更新操作要先更新toAdd.next后更新pred.next，简单理解为：先后-后前)；
4. 更新size。

deleteAtIndex(index)，实现过程：

1. 判断参数有效性；
2. 找前驱节点pred；
3. 更新pred.next == pred.next.next 删除节点；
4. 更新size。

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++) {//注意index的取值，这里常常是易错点
            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;//理清楚自己做这步操作，需要哪些节点的信息，一般插入都需要n节点前一个节点的信息
        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;
    }
}

206.反转链表 

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

建议先看我的视频讲解，视频讲解中对 反转链表需要注意的点讲的很清晰了，看完之后大家的疑惑基本都解决了。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html

解题思路&代码

方法1：双指针

通过pre，cur两个指针，由pre指向cur 改变成 cur指向pre

思路：

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;//pre初始化的思路很值得学习，考虑翻转指针的边界，尾节点会指向null
        ListNode cur = head;
        ListNode temp = null;
        while(cur != null) {//这个临界条件是在pre，cur一直遍历到尾节点时发现的特殊值，要极限情况去找边界
            temp = cur.next;//提前保存好cur.next，因为指针翻转后，还需要下一个节点的位置信息进行遍历
            cur.next = pre;//翻转指针
            pre = cur;//这里要区分好先后顺序，先cur=temp，pre就移不到之前cur的位置了
            cur = temp;
        }
        return pre;//输出链表头节点的信息，就能得到整个链表

    }
}

方法2：递归

思路：采用一个LeetCode给的reverseList翻转函数去执行翻转操作，一次递归执行完进入下一次递归

class Solution {
    public ListNode reverseList(ListNode head) {
        return reverse(null, head);//初始化的思路和双指针是一致的，所以要深刻理解双指针的解法
    }

    private ListNode reverse(ListNode prev, ListNode cur) {
        if (cur == null) {//边界条件，此时翻转完毕，同样是双指针的思路
            return prev;
        }
        ListNode temp = null;
        temp = cur.next;// 先保存下一个节点
        cur.next = prev;// 反转
        // 更新prev、cur位置
        // prev = cur;
        // cur = temp;
        return reverse(cur, temp);
    }
}