③ 链表

原创已于 2023-02-17 22:45:06 修改 · 120 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #数据结构

于 2023-02-17 22:41:48 首次发布

Java之路专栏收录该内容

6 篇文章

订阅专栏

文章介绍了如何在链表中删除指定元素，包括针对头结点和非头结点的不同处理，以及通过添加虚拟头结点简化操作。此外，还讨论了设计链表的数据结构，包括添加、删除和获取元素的方法。最后，提到了两种反转链表的方法：双指针和递归解法。

203. 移除链表元素

注意点：

针对头结点和非头结点的移除元素的方式不一样

可以加入一个虚拟头结点，那么删除链表中的所以元素都可以按照一个统一方式

代码：

// 原链表删除元素
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        // 头节点特殊处理，是一个持续处理的过程
        while(head != null && head.val == val){
            head = head.next;
        }
        // 非头节点的处理
        ListNode cur = head;   // 定义一个临时指针，记录被删除元素的前一个指针
        while(cur != null && cur.next != null){
            if(cur.next.val == val){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
        }
        return head;
    }
}
// 使用虚拟头结点
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){
            return head;
        }
        // 设置一个虚拟头结点，统一删除操作
        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;
            }
            cur = cur.next;
        }
        return dummy.next;
    }
}

707. 设计链表

题目链接：https://leetcode.cn/problems/design-linked-list/

代码：

// 单链表
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);
    }
    
    // 获取第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++){
            currentNode = currentNode.next;
        }
        return currentNode.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 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--;
        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. 反转链表

注意点：

解题方法：双指针解法、递归解法

代码：

// 双指针解法
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode cur = head;   // 定义一个指针指向头结点
        ListNode prev = null;     // 也就是链表的尾巴
        ListNode temp = null;      // 临时指针，保存被断开的节点
        while (cur != null) {
            temp = cur.next;// 保存下一个节点
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
}