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

目录

链表理论基础

Leetcode 203 移除链表元素

Leetcode 707 设计链表

Leetcode 206 反转链表

---

链表理论基础

文章链接：代码随想录_链表理论基础

定义：链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

• 链表的入口节点称为链表的头结点也就是head。

类型：

1. 单链表
2. 双链表：有两个指针域
3. 循环链表：首尾相连

• 在内存中不是连续分布的，通过指针连接

数组与链表的对比：

链表定义：

public class ListNode {
    // 结点的值
    int val;

    // 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

---

Leetcode 203 移除链表元素

题目链接：Leetcode_203_移除链表元素

文档讲解：代码随想录_移除链表元素

视频讲解：b站讲解

第一想法：从前往后搜索，如果当前指针的数值等于要删除的数字，就从链表里删除这个节点。很粗糙，不知道怎么写。其中涉及的问题很多，要找前一个结点和后一个节点，另外还要考虑第一个节点和最后一个节点的问题。

学习记录：

写法一：原链表删除元素

        要创建一个临时指针temp，保证head的内容不被修改。由于为单链表，为了保证前一个结点和后一个节点可以找到，判断temp.next的值是否与目标数值相同，相同则temp.next指向temp.next.next（跳过temp.next）。

class Solution {
    public ListNode removeElements(ListNode head, int val) {
       while(head!=null && head.val == val){
           head = head.next;
       }
       ListNode temp = head; //要引入一个temp指向head，不能直接对head进行操作，保证head不被修改
       while(temp != null && temp.next != null){
           if(temp.next.val == val){
               temp.next = temp.next.next;
           }
           else{
               temp=temp.next;
           }
       }
       return head;
    }
}

写法二：使用虚拟头节点

        引入一个虚拟头节点，使所有节点操作一致，不必单独考虑头节点。

        要注意此种写法的返回值不再是head，而是虚拟头节点的下一个节点。

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return head;
        }
        ListNode dummy = new ListNode(-1, head);
        ListNode temp = dummy; 
        while(temp != null && temp.next != null){
            if(temp.next.val == val){
                temp.next = temp.next.next;
            }
            else{
                temp=temp.next;
            }
        }
        return dummy.next;//注意返回值不再是head！
    }
}

---

 Leetcode 707 设计链表

题目链接：Leetcode_707_设计链表

文档讲解：代码随想录_设计链表

视频讲解：b站讲解

解法：

        引入上一道题的虚拟头节点的思想。

class ListNode {
    int val;
    ListNode next;

    public ListNode() {}

    public 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) {
        ListNode tmp = head;
        if(index<0 || index>=size){
                return -1;
        }
        for(int i=0;i<=index;i++){
            tmp = tmp.next;
        }
        return tmp.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;
        }
        size = size+1;
        ListNode dummp = new ListNode(-1);  //创建虚拟头节点，当作下标为-1的节点
        dummp.next = head;
        ListNode tmp = dummp;  //创建临时指针
        for(int i=0;i<=index;i++){
            tmp = tmp.next;    //移动到要插入的位置的前一个节点
        }
        ListNode old = tmp.next;   //记录当前位置的节点
        ListNode insert = new ListNode(val);
        tmp.next = insert;    //前一个节点的后一个节点赋值为新节点
        insert.next = old;    //新节点的下一个节点为旧节点，实现插入
    }
    
    public void deleteAtIndex(int index) {
        if(index<0 || index>=size){
                return;
        }
        size = size-1;
        ListNode dummp = new ListNode(-1);  //创建虚拟头节点，当作下标为-1的节点
        dummp.next = head;
        ListNode tmp = dummp;
        for(int i=0;i<=index;i++){
            tmp = tmp.next;       //移动到要删除的位置的前一个节点
        }
        tmp.next = tmp.next.next;
    }
}

---

Leetcode 206 反转链表

题目链接：Leetcode_206_反转链表

文档讲解：代码随想录_反转链表

视频讲解：b站讲解

学习记录

        链表只需要改变指针指向即可实现反转

写法一：双指针写法

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode tmp = head;
        while(cur!=null){
            tmp = tmp.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
}

写法二：递归写法

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);
    }
}