算法系列--链表问题

Mylvzi2024-07-11 12:18

一.一些经验总结

  1. 链表天然具有递归性质,单链表可以看做一个单叉树,很多可以应用到二叉树的题目也可以应用到链表的题目之中,下面是一个体现单链表递归性质很好的例子逆序打印链表的值
java 复制代码 
private void reversePrint(ListNode head) {
	if(head == null) return;
	reversePrint(head.next);
	System.out.println(head.val)
}

不难发现这种打印方式很像二叉树中的后序遍历

  1. 对于链表的题目,思路往往很容易想到,只是过程可能有点复杂,一定要多画图,一定要舍得用变量

二.例题讲解

01.删除排序链表中重复的元素

链接:https://leetcode.cn/problems/remove-duplicates-from-sorted-list/description/
分析

  • 这是链表去重的经典问题,有多种解法
  • 最容易想到的解法就是使用一个去重的数据结构(Set),遍历整个链表
  • 最优秀的解法是一个指针,一次遍历,注意题目条件,数组是有序的,那么重复元素一定是相邻的,每遍历到一个节点,就判断cur.val == cur.next.val,如果相等,就删除cur.next(完成一次删除操作);如果不等,直接让cur向后走一步即可

代码:

java 复制代码 
/**
 * 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.val ==cur.next.val) cur.next = cur.next.next;
            else cur = cur.next;// 有可能直接走到null
        }
        return head;
    }
}

说明:

  1. 循环的条件往往是根据下面的判断条件决定的,判断条件是cur.val == cur.next.val,如果cur.next ==null,则会触发空指针异常,所以循环的条件是cur.next != null,对于链表的最后一个元素,要么是重复元素,要么不是重复元素,如果是重复元素,则前一个节点的值和当前节点的值相等,在上一步就会执行删除操作;如果不是重复元素,不用删除
  2. 为什么存在重复元素的情况,删除重复元素之后不让cur走一步?因为有可能删除的是最后一个元素,这样cur.next = null,如果让cur向后走一步,在下一步的循环判断中就会触发空指针异常

删除重复元素的进阶版

链接:https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii/description/
分析

  • 本题相较于上一题,需要将所有的重复元素都删除,而上一题是只保留重复元素的一个
  • 同样也可以采用一个指针,一次遍历的操作,不过本题要删除所有的重复元素,就不能让指针走到重复元素的位置,应该走到第一个重复元素的前去节点,即判断cur.next.val == cur.next.next.val,如果相等,则一直循环删除所有等于cur.next.val(设为x)的所有节点,直到值不为x
  • 循环条件和判断条件的确立同上一题

代码:

java 复制代码 
/**
 * 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 phead = new ListNode(0);
        phead.next = head;
        ListNode cur = phead;

        while(cur.next != null && cur.next.next != null) {
            if(cur.next.val == cur.next.next.val) {
                int x = cur.next.val;
                while(cur.next != null && cur.next.val == x)// 一直走到值不等于x的节点
                    cur.next = cur.next.next;
            }else {
                cur = cur.next;
            }
        }
        return phead.next;

    }
}

02.反转链表

链接:https://leetcode.cn/problems/reverse-linked-list/
分析

1.方法一:使用两个指针迭代完成局部的链表的反转

java 复制代码 
/**
 * 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) {
        if(head == null) return null;
        ListNode pre = null, cur = head;
        while(cur != null) {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;// pre此时是原链表的最后一个节点  反转链表的头结点
    }
}

2.方法2:递归写法

  • 你给我反转当前节点(head)后面的所有节点,并且把反转后的头节点返回
  • 反转当前节点和后面的节点,将后面的节点当做一个节点即可
java 复制代码 
/**
 * 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) {
        if(head == null || head.next == null) return head;

        ListNode newHead = reverseList(head.next);

        // 完成一次局部的反转
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}
  • 为什么返回newHead而不是head?因为newHead是完成反转之后的新的头结点

03.回文链表

链接:https://leetcode.cn/problems/palindrome-linked-list/description/
分析

方法1:栈

遇到对称有关的问题应该先考虑能否使用stack这种数据结构解决,对称问题最大的特点就是从前往后遍历的结果和从后往前遍历的结果相同,从前往后遍历容易,关键在于对于某些问题从后往前遍历很困难(比如单链表),这是就可以使用栈这种数据结构,充分利用栈后进先出的结构特点完成从后往前遍历

java 复制代码 
/**
 * 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 boolean isPalindrome(ListNode head) {
        // 借助栈
        Stack<Integer> st = new Stack<>();
        ListNode i1 = head;

        // 1.将所有元素入栈
        while(i1 != null) {
            st.push(i1.val);
            i1 = i1.next;
        }

        // 2.依次出栈进行比较
        ListNode i2 = head;
        while(i2 != null) {
            if(st.peek() != i2.val) return false;
            else {
                i2 = i2.next;
                st.pop();
            }
        }
        return true;
    }
}

方法2:反转后半部分链表,依次进行比较

  1. 利用快慢指针找到中间节点
  2. 根据fast是否为null判断节点的个数是奇数还是偶数,如果是奇数,向前走一步:如果是偶数,无需移动
  3. 反转后面的所有节点,依次向后比较
java 复制代码 
/**
 * 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 boolean isPalindrome(ListNode head) {
        ListNode fast = head, slow = head;
        // 通过快慢指针找到中点
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        // 如果fast不为空，说明链表的长度是奇数个
        if (fast != null) {
            slow = slow.next;
        }
        // 反转后半部分链表
        slow = reverse(slow);

        fast = head;
        while (slow != null) {
            // 然后比较，判断节点值是否相等
            if (fast.val != slow.val)
                return false;
            fast = fast.next;
            slow = slow.next;
        }
        return true;
    }

    // 反转链表
    public ListNode reverse(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode newHead = reverse(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }

}
相关推荐
Captain823Jack28 分钟前
nlp新词发现——浅析 TF·IDF
人工智能·python·深度学习·神经网络·算法·自然语言处理
Captain823Jack1 小时前
w04_nlp大模型训练·中文分词
人工智能·python·深度学习·神经网络·算法·自然语言处理·中文分词
Aileen_0v02 小时前
【AI驱动的数据结构：包装类的艺术与科学】
linux·数据结构·人工智能·笔记·网络协议·tcp/ip·whisper
是小胡嘛2 小时前
数据结构之旅：红黑树如何驱动 Set 和 Map
数据结构·算法
m0_748255022 小时前
前端常用算法集合
前端·算法
呆呆的猫2 小时前
【LeetCode】227、基本计算器 II
算法·leetcode·职场和发展
Tisfy2 小时前
LeetCode 1705.吃苹果的最大数目：贪心(优先队列) - 清晰题解
算法·leetcode·优先队列·贪心·堆
余额不足121382 小时前
C语言基础十六：枚举、c语言中文件的读写操作
linux·c语言·算法
yuanManGan4 小时前
数据结构漫游记：静态链表的实现(CPP)
数据结构·链表
火星机器人life5 小时前
基于ceres优化的3d激光雷达开源算法
算法·3d
热门推荐
0119个Web前端交互式3D JavaScript框架和库02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04RAG 实践- Ollama+RagFlow 部署本地知识库05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07【一文读懂】NTN（非地面网络）技术介绍08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10ZZ038 物联网应用与服务赛题第J套