力扣刷题篇之链表1

阿如村保安

已于 2023-11-04 13:57:25 修改

阅读量277

点赞数 16

分类专栏：算法与数据结构 leetcode 文章标签：算法数据结构 java 1024程序员节

于 2023-11-04 13:54:37 首次发布

本文链接：https://blog.csdn.net/m0_66076989/article/details/134188021

版权

算法与数据结构同时被 2 个专栏收录

35 篇文章 1 订阅

订阅专栏

leetcode

20 篇文章 0 订阅

订阅专栏

系列文章目录

前言

本系列是个人力扣刷题，本文是链表。刷题顺序按照[力扣刷题攻略] Re：从零开始的力扣刷题生活 - 力扣（LeetCode）

一、移除与插入链表元素

讲道理，我一开始看到这种题一般是头晕的，文字好多，实现一个类，有种带着镣铐跳舞的感觉：

首先初始化一个链表，有head和tail两个节点；

get(int index)方法通过比较索引index与链表长度的一半来确定从头结点还是尾结点开始遍历链表，以找到目标节点，并返回其值。
addAtHead(int val)方法调用addAtIndex(0, val)，将值为val的新节点插入到链表头部。
addAtTail(int val)方法调用addAtIndex(size, val)，将值为val的新节点插入到链表尾部。
addAtIndex(int index, int val)方法首先判断索引index是否越界，然后根据索引与链表长度的一半的比较，选择从头结点还是尾结点开始遍历链表，找到插入位置的前后节点，并创建新节点插入到两个节点之间。
deleteAtIndex(int index)方法首先判断索引index是否越界，然后根据索引与链表长度的一半的比较，选择从头结点还是尾结点开始遍历链表，找到要删除的节点的前后节点，并进行删除操作。

class MyLinkedList {
    int size;
    ListNode head;
    ListNode tail;

    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
        tail = new ListNode(0);
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        ListNode cur;
        if(index + 1 < size - index){
            cur = head;
            for(int i=0;i<=index;++i){
                cur = cur.next;
            }
        }else{
            cur = tail;
            for(int i=0;i<size-index;++i){
                cur = cur.prev;
            }
        }
        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;
        }
        index = Math.max(0, index);
        ListNode bef,aft;
        if(index < size -index){
            bef = head;
            for(int i=0;i<index;++i){
                bef = bef.next;
            }
            aft = bef.next;
        }else{
            aft = tail;
            for(int i=0;i<size-index;++i){
                aft = aft.prev;
            }
            bef = aft.prev;
        }
        size++;
        ListNode toAdd = new ListNode(val);
        toAdd.prev = bef;
        toAdd.next = aft;
        bef.next = toAdd;
        aft.prev = toAdd;
    }
    
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        ListNode pred,succ;
                if (index < size - index) {
            pred = head;
            for (int i = 0; i < index; i++) {
                pred = pred.next;
            }
            succ = pred.next.next;
        } else {
            succ = tail;
            for (int i = 0; i < size - index - 1; i++) {
                succ = succ.prev;
            }
            pred = succ.prev.prev;
        }
        size--;
        pred.next = succ;
        succ.prev = pred;
    }
}

class ListNode{
    int val;
    ListNode next;
    ListNode prev;

    public ListNode(int val){
        this.val = val;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

比较简单，但边界条件重视一下：

代码 ListNode sentinel = new ListNode(-1, head); 创建了一个特殊的节点 sentinel，它具有值为 -1，且 next 引用指向链表的头结点 head。

这种做法通常被称为 Sentinel 节点或者 Dummy 节点。Sentinel 节点是在链表的头部或尾部添加的一个额外节点，目的是简化链表的操作，避免处理头部和尾部节点的边界情况。

在这个实现中，sentinel 节点的值为 -1，可作为一个特殊标记，表示该节点不存储有效的数据。它的存在主要是为了简化链表操作的一致性。

通过引入 sentinel 节点，可以确保链表的头部始终存在一个有效的节点，即使链表为空。这样，在执行链表的插入、删除等操作时，就无需再考虑链表为空的情况，简化了代码的实现逻辑。

此外，通过 sentinel 节点，还可以避免处理头部节点和其他节点之间的特殊情况，例如在插入或删除节点时，始终可以使用相同的逻辑来处理。这种一致性能够提高代码的可读性和可维护性。

总而言之，sentinel 节点在该链表实现中起到了简化操作和处理边界情况的作用，提高了代码的可读性和可维护性。

/**
 * 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 sentinel = new ListNode(-1,head);  //值为-1，next指向head，处理边界情况
        ListNode p1 = sentinel;
        ListNode p;
        while((p=p1.next)!=null){
            if(p.val==val){
                p1.next=p.next;
            }else{
                p1=p1.next;
            }
        }
        return sentinel.next;
    }
}

题意简单来说就是不能访问到head，但是要删给定的节点，简单。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;    //变成下个倒霉蛋
        node.next = node.next.next;  //把倒霉蛋干掉。
    }
}

边界条件多一点也可以如此，但显然上面那个更简单：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        // node.val = node.next.val;    //变成下个倒霉蛋
        // node.next = node.next.next;  //把倒霉蛋干掉。
        ListNode tmp = node.next;
        while (tmp.next != null) {
            node.val = tmp.val;
            node = node.next;
            tmp = tmp.next;
        }
        node.val = tmp.val;
        node.next = null;
    }
}

双指针，quick先走n-1步，然后slow和quick同时走，quick到达末尾，slow则处于倒数第n个节点。注意边界条件。

/**
 * 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 removeNthFromEnd(ListNode head, int n) {

        if (head == null || head.next == null) {
            return null;
        }

        ListNode slow = head;
        ListNode quick = head;
        int count = 0;
        while (count < n - 1) {
            quick = quick.next;
            count++;
        }


        ListNode prev = slow;
        boolean notRun = true;
        while (quick != null && quick.next != null) {
            prev = slow;
            quick = quick.next;
            slow = slow.next;
            notRun = false;
        }

        if (notRun) { // 处理只有两个节点，且删除倒数第二节点情况
            head = head.next;
            return head;
        }

        if (prev != slow) {
            prev.next = slow.next;
        }

        return 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 deleteDuplicates(ListNode head) {
        if (head == null)
            return null;
        ListNode cur = head;
        while (cur.next != null)
            if (cur.next.val == cur.val)
                cur.next = cur.next.next;
            else
                cur = cur.next;
        return head;
    }
}

这个较上一题复杂了一点，首先比上一题多两种情况

一，他可能head开始就和下一个节点val相同，那么head就也要删除，所以加入一个sentinel边界，指向head。

二，他可能连续不止两个节点相同（排过序的链表，相同的节点一定连续），有多个，这个时候就要用到三指针。cur无论什么情况都要移动，方便处理相同元素，pre用于重构链表。

/**
 * 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 deleteDuplicates(ListNode head) {
        if(head==null) return null;
        ListNode sentinel = new ListNode(-1, head);
        ListNode pre=sentinel;
        ListNode cur=head;
        while(cur!=null && cur.next!=null){
            if(cur.val==cur.next.val){
                while(cur.next!=null&&cur.val==cur.next.val){
                    cur=cur.next;
                }
                pre.next=cur.next;
            }else{
                pre=pre.next;
            }
            cur=cur.next;
        }
        return sentinel.next;
        
    }
}

二、链表的遍历

这一题有点让我想到二叉树，pre-child-next的顺序连接，最后返回的列表需要有pre和next。

有子节点向子节点遍历，没有子节点就向后遍历，记得pre和next都要加上。

/*
// Definition for a Node.
class Node {
    public int val;
    public Node prev;
    public Node next;
    public Node child;
};
*/

class Solution {
    public Node flatten(Node head) {
        if (head == null) {
            return null;
        }
        Node node = head;
        child(node);
        return head;
    }
    public Node child(Node node) {
        //遍历终止条件: 1.有子节点  2.下一个节点为null说明已经在当前层级尾部了
        while (node.child != null || node.next != null) {
            if (node.child != null) {
                //有子节点就递归
                Node child = child(node.child);
                //这个child代表子节点那个层级的最后一个节点
                if (node.next != null) {
                    //我们需要把child和当前节点的下一个节点关联起来(如果存在的话)
                    child.next = node.next;
                    node.next.prev = child;
                }
                //此时已经不需要子节点了 把子节点变成当前节点的下一个节点
                node.next = node.child;
                node.child.prev = node;
                node.child = null;
                //子节点设置好后 继续向后遍历
                node = child;
            } else {
                //没有子节点就往后遍历
                node = node.next;
            }
        }
        return node;
    }
}

先序遍历，dfs,很大佬的解法

使用深度优先搜索（DFS）的方式遍历二叉树，基本思路是遍历二叉树，然后将左子树的节点依次连接到右子树上，同时将左子树置为空。这个过程将原来的二叉树就地展开为链表结构。

额外的 link 变量来辅助构建链表，以及在递归中提前保存左子树和右子树的引用，因为在递归调用过程中，左右子树的指针可能会被改变。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    TreeNode link = new TreeNode();
    public void flatten(TreeNode root) {
        if(root == null) return;
        link.left = null;
        link.right = root;
        link = link.right;
        
        TreeNode left = root.left; // 因为dfs时会改变left和right 指针，所以需要提前保存
        TreeNode right = root.right;
        flatten(left);
        flatten(right);
    }
    
    
}

三、链表的旋转与反转

可以用快慢指针，也可以直接找头尾指针，思路差不多。

/**
 * 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 rotateRight(ListNode head, int k) {
    //     int length = 0;  // 初始化长度为0
    //     ListNode current = head;  // 从链表的头节点开始遍历

    //     while (current != null) {
    //         length++;  // 每遍历一个节点，长度加1
    //         current = current.next;  // 移动到下一个节点
    //     }
    //     if(length<=1) return head;
    //     k=k%length;
    //     ListNode slow=head;
    //     ListNode fast=head;
    //     while(k-->0 && fast.next!=null) fast=fast.next;
    //     while(fast.next!=null){
    //         fast=fast.next;
    //         slow=slow.next;
    //     }
    //     ListNode h=slow.next;
    //     fast.next=head;
    //     slow.next=null;
    //     return h;
    // }
    public ListNode rotateRight(ListNode head, int k) {
        if (head == null || k == 0) {
            return head; // 如果链表为空或 k 等于 0，无需旋转，直接返回原链表
        }

        ListNode tail = head; // 初始化尾节点指向链表头
        int length = 1; // 初始化链表长度为 1
        while (tail.next != null) {
            tail = tail.next;
            length++; // 遍历链表，找到尾节点并计算链表长度
        }

        k = k % length; // 计算实际需要旋转的步数

        if (k == 0) {
            return head; // 如果 k 对链表长度取模等于 0，无需旋转，直接返回原链表
        }

        ListNode newTail = head; // 新的尾节点从链表头开始
        for (int i = 1; i < length - k; i++) {
            newTail = newTail.next; // 找到新的尾节点
        }

        ListNode newHead = newTail.next; // 新的头节点即为新的尾节点的下一个节点
        newTail.next = null; // 断开链表

        tail.next = head; // 原来的尾节点指向原链表头，形成闭环

        return newHead; // 返回旋转后的链表的头节点
    }

}

想了半天，没想出来，评论区有大佬用递归。genius！！！

使用递归来解决该题，主要就是递归的三部曲：

找终止条件：本题终止条件很明显，当递归到链表为空或者链表只剩一个元素的时候，没得交换了，自然就终止了。
找返回值：返回给上一层递归的值应该是已经交换完成后的子链表。
单次的过程：因为递归是重复做一样的事情，所以从宏观上考虑，只用考虑某一步是怎么完成的。我们假设待交换的俩节点分别为head和next，next的应该接受上一级返回的子链表(参考第2步)。就相当于是一个含三个节点的链表交换前两个节点，就很简单了，想不明白的画画图就ok。

搞清楚递归套路：博客链接

/**
 * 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 swapPairs(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode next = head.next;
        head.next = swapPairs(next.next);
        next.next = head;
        return next;
    }
}

迭代：

/**
 * 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 cur = head; // 定义cur指针指向头结点
       ListNode pre = null;   // 定义 pre 空指针 表示头结点前一个节点
       ListNode temp = null;  // 定义一个临时的指针 temp
       while(cur != null){ 
           temp = cur.next; // 保存下一个节点
           cur.next = pre;     //进行翻转赋值
           // 指针向后移动
           pre = cur;  
           cur = temp; 
       }
       return pre;
   }
}

递归：

/**
 * 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 preNode=null;
    //     ListNode curr=head;
    //     while(curr!=null){
    //         ListNode next=curr.next;
    //         curr.next=preNode;
    //         preNode=curr;
    //         curr=next;
    //     }
    //     return preNode;

    // }

    //递归，从后向前
    public ListNode reverseList(ListNode head){
        if(head==null||head.next==null){
            return head;
        }
        ListNode new_head=reverseList(head.next);
        head.next.next=head;
        head.next=null;
        return new_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 reverseBetween (ListNode head, int left, int right) {
        ListNode listNode = new ListNode(-1);
        listNode.next = head;
        ListNode rightNode = head;
        ListNode leftNode = listNode;
        for (int i = 0; i < left - 1; i++) {
            leftNode = leftNode.next;
        }
        for (int i = 0; i < right; i++) {
            rightNode = rightNode.next;
        }
        leftNode.next = reverseLinkedList(leftNode.next,rightNode);
        return listNode.next;
    }
  // 功能函数，翻转链表
    public ListNode reverseLinkedList(ListNode left,ListNode right){
      // right相当于以前的null,以前翻转整个链表，自然是到尾巴，这次就到right
        ListNode prev = right;
      // 这里的left相当于以前的head，只不过这次的头并不一定是第一个节点
        ListNode curr = left;
      // 循环条件也要响应改变，以前是head!=null,这次同理，curr!=right,直到2,3,4这几个节点翻转完毕
        while(curr!=right){
          // 常规翻转链表操作，先记录后面一个结点，然后让指向前一个，然后地址赋值
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}

这道题我一开始肯定想调用反转函数做，但发现不太行，按下面代码的逻辑进行翻转，每次内层循环都能翻转前k个数，一次内层循环后，prev跳到curr处，就是上次循环的最后一个节点，也是下次循环的上一个节点，继续反转之后的k个数，反转（length/k）次。很厉害。

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(0), prev = dummy, curr = head, next;
        dummy.next = head;
        int length = 0;
        while(head != null) {
            length++;
            head = head.next;
        }
        head = dummy.next;
        for(int i = 0; i < length / k; i++) {
            for(int j = 0; j < k - 1; j++) {
                next = curr.next;
                curr.next = next.next;
                next.next = prev.next;
                prev.next = next;
            }
            prev = curr;
            curr = prev.next;
        }
        return dummy.next;
    }
}

总结

链表相对于数组而言要难一点，我也意识到自己对于树的知识点以及递归的套路还要加强理解，但总的而言，链表的题比较套路。多敲。

这次总结了如下三部分的链表题。

阿如村保安

关注

16
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
力扣刷题篇之链表1

本系列是个人力扣刷题，本文是链表。刷题顺序按照[力扣刷题攻略] 。链表相对于数组而言要难一点，我也意识到自己对于树的知识点以及递归的套路还要加强理解，但总的而言，链表的题比较套路。多敲。这次总结了如下三部分的链表题。
复制链接

扫一扫