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

目录

链表理论基础

Leetcode 203 移除链表元素

Leetcode 707 设计链表

Leetcode 206 反转链表


链表理论基础

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

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

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

类型:

  1. 单链表代码随想录算法训练营第三天 | 链表理论基础 、Leetcode 203 移除链表元素、Leetcode 707 设计链表、Leetcode 206 反转链表_第1张图片
  2. 双链表:有两个指针域代码随想录算法训练营第三天 | 链表理论基础 、Leetcode 203 移除链表元素、Leetcode 707 设计链表、Leetcode 206 反转链表_第2张图片
  3. 循环链表:首尾相连

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

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

数组与链表的对比:

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

链表定义

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

你可能感兴趣的:(代码随想录,算法,链表,leetcode)