【Leecode笔记】第十七周上（12.28-12.29）链表专题

最新推荐文章于 2023-12-29 20:26:52 发布
最新推荐文章于 2023-12-29 20:26:52 发布
阅读量143 收藏
点赞数
分类专栏： Leecode 文章标签： leetcode 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40335368/article/details/111830497
版权

【第一题】删除链表的节点

在这里插入图片描述

分析：双指针。

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：37.9 MB, 在所有 Java 提交中击败了70.57% 的用户
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if(head == null){
            return head;
        }
        ListNode cur = head;
        ListNode pre = null;
        if(cur.val == val) return head.next;
        while(cur.val != val){
            pre = cur;
            cur = cur.next;
        }
        pre.next = pre.next.next;
        return head;
    }
}

【第二题】链表的中间结点

在这里插入图片描述

分析：快慢指针。从第一个结点开始出发，快指针每次走两步，慢指针每次走一步，当快指针走到终点，慢指针走到中点。

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.5 MB, 在所有 Java 提交中击败了81.76% 的用户
class Solution {
    public ListNode middleNode(ListNode head) {
        if(head == null) return null;
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null && fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
}

【第三题】移除链表元素

在这里插入图片描述

分析：缝缝补补终于过了！淦我好菜！

//执行用时：1 ms, 在所有 Java 提交中击败了99.49% 的用户
//内存消耗：39.2 MB, 在所有 Java 提交中击败了85.31% 的用户
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){return null;}
        if(head.val == val && head.next== null){return null;}
        if(head.val != val && head.next == null){return head;}
        
        //假如当前指向的结点值为val,那么直接换头节点
        while(head.next!=null && head.val == val){
            head = head.next;
        }
        if(head.val == val && head.next== null){return null;}
        if(head.val != val && head.next == null){return head;}

        ListNode cur = head;
        while(cur.next !=null && cur.next.next !=null){
            if(cur.next.val == val){
                if(cur.next.next == null){
                    cur.next = null;
                }else{
                    cur.next = cur.next.next;
                }
            }else{
                cur = cur.next;
            }
            
        }
        
        if(cur.next!=null && cur.next.val == val){
            cur.next = null;;
        }
        return head;
    }
}

//双指针
//执行用时：1 ms, 在所有 Java 提交中击败了99.49% 的用户
//内存消耗：39.7 MB, 在所有 Java 提交中击败了26.63% 的用户
class Solution{
    public ListNode removeElements(ListNode head,int val){
        ListNode header = new ListNode(-1);
        header.next = head;
        ListNode cur = header;
        //这里在头节点前设置结点，避免了判断头节点为删除结点
        while(cur.next != null){
            if(cur.next.val == val){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
        }
        return header.next;
    }
}

【第四题】两个链表的第一个公共结点

在这里插入图片描述在这里插入图片描述

分析：
方法一：先遍历两个列表，得出列表的长度，然后求出两者长度之差n，让指向长列表的指针先走n步，然后两个指针一起走，当他们指向相桶的结点时，返回该节点即可。

方法二：交集链表；

方法三：集合。将结点加入集合，在加入的过程中碰到第一个已存在的结点时，返回该节点。

//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：41.2 MB, 在所有 Java 提交中击败了75.31% 的用户
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //两者都为空
        if(headA == null || headB == null){return null;}
        //两者都只有一个结点
        if(headA.next == null && headB.next == null && headA == headB){
            return headA;
        }
        //其中一个链表只有一个结点
        if(headA.next == null){
            if(headB.next== headA){return headA;}
        }
        if(headB.next == null){
            if(headA.next == headB){return headB;}
        }
        //两个链表都不止一个结点
        //遍历一遍得到长度
        ListNode i = headA;
        ListNode j = headB;
        int lenA = 0,lenB = 0;
        while(i.next!=null){
            i = i.next;
            lenA++;
        }
        while(j.next!=null){
            j = j.next;
            lenB++;
        }
        //System.out.println(lenA+" "+lenB);
        int n = Math.abs(lenB-lenA);
        i = headA;
        j = headB;
        //int n = Math.abs(skipA - skipB);
        while(n!=0){
            if(lenA > lenB){
                i = i.next;
            }else{
                j = j.next;
            }
            n--;
        }
        // System.out.println(j.val);
        while(i.next!=null && j.next!=null){
            if(i == j){
                return i;
            }
            i = i.next;
            j = j.next;
        }
        return i == j?i:null;
    }
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：40.8 MB, 在所有 Java 提交中击败了98.80% 的用户
//当其中一个走到尽头，回到起点，继续与未走到尽头的一起向前。
public ListNode getIntersectionNode(ListNode headA,ListNode headB){
	ListNode h1 = headA,h2 = headB;
	while(h1 !=h2){
		h1 = h1 == null?headB:h1.next;
		h2 = h2 == null?headA:h2.next;
	}
	return h1;
}

//用集合好慢
//执行用时：8 ms, 在所有 Java 提交中击败了16.26% 的用户
//内存消耗：42.3 MB, 在所有 Java 提交中击败了5.59% 的用户
public ListNode getIntersectionNode(ListNode headA,ListNode headB){
	Set<ListNode> set = new HashSet<>();
	while(headA!=null){
		set.add(headA);
		headA = headA.next;
	}
	while(headB !=null){
		if(set.contains(headB)){
			return headB;
		}
		headB = headB.next;
	}
	return null;
}

【第五题】反转链表

在这里插入图片描述

分析：看见反转——>立即推，栈，双指针，reverse，递归。
链表的反转——>头插法。

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：38.1 MB, 在所有 Java 提交中击败了83.24% 的用户
class Solution{
    public ListNode reverseList(ListNode head){
        if(head == null || head.next == null){return head;}
        ListNode i = new ListNode(0);
        i.next = head;
        ListNode cur = head.next;
        head.next =null;
        while(cur!=null){
            ListNode temp = cur.next;
            cur.next = head;
            i.next = cur;
            head = i.next;
            //cur.next = null;
            cur = temp;
        }
        return i.next;
    }
}

【第六题】链表相交

分析：判断链表是否相交

//套用交集那个题，但是好慢
//执行用时：391 ms, 在所有 Java 提交中击败了6.07% 的用户
//内存消耗：41 MB, 在所有 Java 提交中击败了86.98% 的用户
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode h1 = headA;
        ListNode h2 = headB;
        while(h1 !=h2){
            h1 = h1 == null?headA:h1.next;
            h2 = h2 == null?headB:h2.next;
        }
        if(h1 == null && h1 == h2){
            return null;
        }
        return h1;
    }
}

//风水轮流转，这个写法居然比上边那个效率要高了
//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：41.2 MB, 在所有 Java 提交中击败了67.90% 的用户
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //两者都为空
        if(headA == null || headB == null){return null;}
        //两者都只有一个结点
        if(headA.next == null && headB.next == null && headA == headB){
            return headA;
        }
        //其中一个链表只有一个结点
        if(headA.next == null){
            if(headB.next== headA){return headA;}
        }
        if(headB.next == null){
            if(headA.next == headB){return headB;}
        }
        //两个链表都不止一个结点
        //遍历一遍得到长度
        ListNode i = headA;
        ListNode j = headB;
        int lenA = 0,lenB = 0;
        while(i.next!=null){
            i = i.next;
            lenA++;
        }
        while(j.next!=null){
            j = j.next;
            lenB++;
        }
        //System.out.println(lenA+" "+lenB);
        int n = Math.abs(lenB-lenA);
        i = headA;
        j = headB;
        //int n = Math.abs(skipA - skipB);
        while(n!=0){
            if(lenA > lenB){
                i = i.next;
            }else{
                j = j.next;
            }
            n--;
        }
        // System.out.println(j.val);
        while(i.next!=null && j.next!=null){
            if(i == j){
                return i;
            }
            i = i.next;
            j = j.next;
        }
        return i == j?i:null;
    }
}

【第七题】相交链表（和前两题一样）

【第八题】回文链表

分析：
方法一：栈
方法二：将链表的值都填入数组，然后用双指针

//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：41 MB, 在所有 Java 提交中击败了77.43% 的用户
class Solution {
    public boolean isPalindrome(ListNode head) {
        //if(head)
        int len = 0;
        ListNode i = head;
        while(i!=null){
            i = i.next;
            len++;
        }
        int[] arr = new int[len];
        for(int j = 0;j < len;j++){
            arr[j] = head.val;
            head = head.next;
        }
        int k = 0,j = len-1;
        while(k < j){
            if(arr[k] !=arr[j]){
                return false;
            }
            k++;
            j--;
        }
        return true;
    }
}

【第九题】删除排序链表中重复的元素

方法一：集合去重
方法二：双指针前后比较

//执行用时：5 ms, 在所有 Java 提交中击败了91.51% 的用户
//内存消耗：39.9 MB, 在所有 Java 提交中击败了39.95% 的用户
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null){return null;}
        HashSet<Integer> set = new HashSet<>();
        ListNode cur = head;
        ListNode pre = new ListNode(-1);
        pre.next = cur;
        while(cur!=null){
            if(!set.contains(cur.val)){
                set.add(cur.val);
                pre = pre.next;
                cur = cur.next;
            }else{
                pre.next = cur.next;
                cur = cur.next;
            }
        }
        //System.out.println(set);
        return head;
    }
}

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：37.6 MB, 在所有 Java 提交中击败了90.91% 的用户
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null){return null;}
        if(head.next == null){return head;}
        ListNode cur = head.next;
        ListNode pre = head;
        while(cur.next!=null){
            if(pre.val == cur.val){
                pre.next = cur.next;
                cur = cur.next;
            }else{
                pre = pre.next;
                cur = cur.next;
            }
        }
        if(pre.val == cur.val){
            pre.next = null;
        }
        return head;
    }
}

【第十题】环形链表

在这里插入图片描述

分析：判断链表是否有环。
方法一：快慢指针，有环的话终将相遇。
方法二：集合判重。(好慢好慢好慢)

//执行用时：4 ms, 在所有 Java 提交中击败了19.84% 的用户
//内存消耗：38.9 MB, 在所有 Java 提交中击败了40.89% 的用户
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null){return false;}
        ListNode i = head;
        HashSet<ListNode> set = new HashSet<>();
        while(i!= null){
            if(!set.add(i)){
                return true;
            }
            if(i.next ==null){
                return false;
            }
            i = i.next;
        }
        return true;
    }
}

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：38.4 MB, 在所有 Java 提交中击败了88.82% 的用户
public class Solution{
	public boolean hasCycle(ListNode head){
		if(head == null || head.next == null){
			return false;
		}
		ListNode slow = head;
		ListNode fast = head.next;
		while(slow!=fast){
			if(fast == null || fast.next == null){
				return false;
			}
			slow = slow.next;
			fast = fast.next.next;
		}
		return true;
	}
}

【第十一题】从尾到头打印链表

在这里插入图片描述

分析：
方法一：将结点的值存入栈中，然后将栈中元素一个一个弹到数组中。（这么慢的速度是真实的吗）
方法二：倒过来存到数组中，省略了栈的空间。

//执行用时：2 ms, 在所有 Java 提交中击败了36.94% 的用户
//内存消耗：38.9 MB, 在所有 Java 提交中击败了81.41% 的用户
class Solution {
    public int[] reversePrint(ListNode head) {
        int len = 0;
        Stack<Integer> s = new Stack<>();
        while(head!=null){
            s.push(new Integer(head.val));
            head = head.next;
            len++;
        }
        //System.out.println("stack: " + s);
        int[] arr = new int[len];
        for(int i = 0;i < len;i++){
            arr[i] = (Integer)s.pop();
        }
        return arr;
    }
}

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：39 MB, 在所有 Java 提交中击败了79.15% 的用户
class Solution {
    public int[] reversePrint(ListNode head) {
        int len = 0;
        ListNode cur = head;
        while(cur!=null){
            len++;
            cur = cur.next;
        }
        //System.out.println("stack: " + s);
        int[] arr = new int[len];
        for(int i = len-1;i >=0;i--){
            arr[i] = head.val;
            head = head.next;
        }
        return arr;
    }
}
是菜鸟不是咸鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
LeetCode71--存在重复元素、存在重复元素II、汇总区间
qq_40971025的博客
03-09 128
1.存在重复元素 //给定一个整数数组，判断是否存在重复元素。 // // 如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。 // // // // 示例 1: // // //输入: [1,2,3,1] //输出: true // // 示例 2: // // //输入: [1,2,3,4] //输出: false // // 示例 3: // // //输入: [1,1,1,3,3,4,3,2,4,2] //输出: t
LeetCode2——两数相加（dummy node）
weixin_38933749的博客
06-17 239
题目描述 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例： 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出： 7 -> 0 -> 8 原因： 342 + 465 = 807 题目分析 我们采用dummy node，链表题中经常会遇
本周练习(12.24-12.29
2302_76208914的博客
12-26 338
12.24-12.25：完成视频内容的学习，完善页面。 12.26-12.28：完成BootStrap的学习。
12.28-day1计划
2203_75335776的博客
12-18 455
12.28---Convergence analysis of some algorithms for solving nonsmooth equations（LiQun Qi）
Fullofstars
12-28 150
方向导数、BD正则、非光滑函数、牛顿方法
[每日一题] 12.28 - 整数反转
最新发布
2303_81447590的博客
12-29 377
整数反转
12.28-1.4
AB__C的博客
01-27 120
12月28日 188.买卖股票的最佳时机Ⅳ class Solution { public int maxProfit(int k, int[] prices) { if(prices.length == 0 || k < 1) { return 0; } if(k >= prices.length/2) { return ans1(prices); } int
力扣-12.28-650
Desperate_gh的博客
12-28 125
方法一： 参考：https://leetcode-cn.com/problems/2-keys-keyboard/solution/zhi-you-liang-ge-jian-de-jian-pan-by-leetcode/ 理解为分解素数 class Solution { public int minSteps(int n) { int ans = 0, d = 2; while (n > 1) { while (n % d == 0.
2023寒假每日一题12.28-1.1
m0_66433418的博客
12-28 119
acwing寒假每日一题
12.28-MUX vlan.topo
12-08
12.28-MUX vlan.topo
12.28-史佳媛-消费者金融与理财——基于家庭的分析.zip
09-13
标题中的“12.28-史佳媛-消费者金融与理财——基于家庭的分析”表明这是一份关于消费者金融和理财的讲座或课程材料，由史佳媛在12月28日分享，主要关注家庭层面的财务管理和消费行为。这份资料可能包含了对个人及...
6m48-v2.0-12.28-power-usb
05-15
文件命名“MERGE.bin”，断电插入USB后，开机灯交替自动。
12.28-史佳媛-消费者金融与理财——基于家庭的分析.doc
09-13
在研究方法上，将采用文献资料法、访谈调查法等，深入了解家庭理财的目的、方式和问题。同时，以研究者自身的生活阶段为例，规划各阶段的理财方案，通过实际操作检验和完善理财规划，寻找更合理的解决办法。 国外的...
12.28-史佳媛-消费者金融与理财——基于家庭的分析(1).zip
09-13
《消费者金融与理财——基于家庭的分析》是史佳媛教授的一份专题研究，这份资料深入探讨了在个人和家庭层面上如何理解和实践金融与理财。文档内容可能涵盖了多个方面，包括但不限于以下关键知识点： 1. **消费者...
【Leecode笔记之C语言】第三周（9.21-9.27）
历乱的日记簿
09-22 485
【Day7】 第一题：宝石与石头 分析：直接在S里搜索和J相同的字符，双层for循环可实现。 问题在于：如何判断两个字符是否相等？ 第一个思路：在J中存在；（strchr函数，返回在J中的位置） 第二个思路：两字符相等。（strcmp函数，比较两个字符） int numJewelsInStones(char * J, char * S){ int num = 0; //int len = S.length(); for(int i = 0;S[i]!='\0';i++){
【牛客+力扣】高频题随机刷（5.3-5.9）
历乱的日记簿
05-10 337
1、二叉搜索树的第k个结点 输出第k小的结点 分析： 1、中序遍历二叉搜索树是节点值的升序排列 2、利用ArrayList的随机存取 //中序遍历 public class Solution { ArrayList<TreeNode> res = new ArrayList<>(); TreeNode KthNode(TreeNode pRoot, int k) { if(pRoot == null || k == 0){return null;}
【Leecode笔记之java】第十四周（12.7-12.13）字符串专题
历乱的日记簿
12-14 335
【第一题】验证回文字符串II 分析：双指针，i从开头遍历，j从末尾遍历，一个一个比较，碰到不相同的字符跳过，继续往前，碰到第二个不相同的字符，返回false。 这里问题就在于，当字符不相等的时候，是哪个指针往前走？ 分为两种情况： 1.i向前走，判断是否为回文； 2.j向前走，判断是否为回文。 这里可以设计成一个递归判断。 //执行用时：9 ms, 在所有 Java 提交中击败了56.24% 的用户 //内存消耗：38.8 MB, 在所有 Java 提交中击败了94.35% 的用户 //Q:为啥是(i,j
【Leecode笔记】第十八周下（1.5-1.8）位运算专题
历乱的日记簿
01-08 315
【第一题】丢失的数字 分析： 1.位运算异或。 2.求和。由1到n项的数列和-目前的sum 3.哈希表/桶 //1.位运算异或。 //执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户 //内存消耗：38.9 MB, 在所有 Java 提交中击败了63.68% 的用户 class Solution{ public int missingNumber(int[] nums){ int res = nums.length; for(int i =
与10.110.12.29 mask 255.255.255.252 属于同一网段的主机IP 地址是 （）
06-12
与10.110.12.29 mask 255.255....因为这是一个30位的子网掩码，可以容纳4个主机，其中网络地址是10.110.12.28，广播地址是10.110.12.31，而10.110.12.29是其中的一个主机地址，另外两个是10.110.12.30和10.110.12.31。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值