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

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

链表理论基础

链表相关知识讲解：链表知识点

203.移除链表元素

题目链接： 移除链表元素

文字讲解： 文字讲解

视频讲解： 视频讲解

思路：

• 首先定义一个节点变量，用来找到需要移除元素的前驱，然后通过前驱指向其下下个节点位置来实现删除元素的操作。
• 力扣的链表和我们学的链表有一些差别，这里的head节点就是放第一个元素，然后需要自己定义一个伪头节点，这样的话我们就可以把对头结点的操作和对后面节点的操作统一起来，代码写起来会更加的便捷。
• 以后遇到链表题，就先定义一个伪头结点。

迭代写法：

/**
 * 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(0);
        dummyHead.next = head;
        ListNode pred = dummyHead;
        while(pred.next != null){
            if(pred.next.val == val){
                pred.next = temp.next.next;
            }
            else{
                pred = pred.next;
            }
        }
        return dummyHead.next;
    }
}
//时间复杂度：O(n)
//空间复杂度：O(1)

递归写法：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return head;
        }
        head.next = removeElements(head.next, val);
        return head.val == val ? head.next : head;
    }
}
//时间复杂度：O(n)
//空间复杂度：O(n)

707.设计链表

题目链接： 707. 设计链表 - 力扣（LeetCode）

文字讲解：文字讲解

视频讲解： 视频讲解

思路：

• 我们在添加节点的时候，添加的位置总共有size+1个，所有我们可以取**[0,size]**上面的所有值
• 我们在删除节点的时候，删除的位置总共有size个，所有我们只能取**[0,size)**上面的所有值
• 添加节点和删除节点最重要的都是找到index的前驱，找到了它的前驱进行一些补充操作就可解决问题。

实现代码：

//链表节点定义
class ListNode{
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val){
        this.val = val;
    } 
}
class MyLinkedList {
    int size;  //记录链表长度
    ListNode head;
    //初始化链表
    public MyLinkedList() {
       size = 0;
       head = new ListNode(0);
    }
    //返回某下标元素
    public int get(int index) {
        if(index < 0 || index >=size){
            return -1;
        }
        ListNode cur = head;
        for(int i = 0; i <= index; i++){
            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;
        }
        //如果下标小于0，统一插在第0个位置
        if(index < 0){
            index = 0;
        }
        size++;//插入一个元素，链表个数加1

        //找到插入位置的前驱
        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;
    }
    
    //删除某下标节点
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        size--;
        //找到删除位置的前驱
        ListNode pred = head;
        for(int i = 0; i < index; i++){
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

206.反转链表

题目链接： 206. 反转链表 - 力扣（LeetCode）

文字讲解： 文字讲解

视频讲解： 视频讲解

思路：

• 采用头插法的思路，先将伪头节点的next设置为null，然后将链表元素从前往后，一个一个的插到伪头节点的后面，就可以实现链表的反转。

头插法：

/**
 * 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 dummyHead = new ListNode(0);
        dummyHead.next = head;
        //用来指向需要插入的元素
        ListNode cur = dummyHead.next;
        dummyHead.next = null;
        
        while(cur != null){
            //temp的作用是防止断链
            ListNode temp = cur.next;
            //不断将元素插到伪头节点的后面
            cur.next = dummyHead.next;
            dummyHead.next = cur;
            //将cur指向下一个插入元素
            cur = temp;
        }
        return dummyHead.next;
    }
}
//时间复杂度：O(n)
//空间复杂度：O(1)