Leetcode刷题笔记—List (20)

已于 2024-05-07 00:20:37 修改
阅读量143 收藏
点赞数
文章标签： leetcode 笔记 算法
于 2023-06-22 14:58:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_77651729/article/details/131339503
版权

 430. Flatten a Multilevel Doubly Linked List

class Solution {
    public Node flatten(Node head) {
        if(head == null) {
            return head;
        } // base case 必须写 不然cur.prev = pre 会报空指针异常
        Node dummy = new Node(0);
        Node pre = dummy;
        Stack<Node> stack = new Stack();
        stack.push(head);
        while(!stack.isEmpty()) {
            // 逻辑在这里实现， 
            Node cur = stack.pop();
            cur.prev = pre; 
            pre.next = cur;
            // 下一个node先入栈，child节点再入栈
            if(cur.next != null) {
                stack.push(cur.next);
            }
            if(cur.child != null) {
                stack.push(cur.child);
                cur.child = null; // child入栈后，cur就没有child
            }
            pre = cur;
        }
        dummy.next.prev = null; //第一个node的prev指向null，而不是dummy.prev = null
        return dummy.next;
    }
}

237. Delete Node in a Linked List

class Solution {
    public void deleteNode(ListNode node) {
        if(node != null && node.next != null) {
            // 将node的值设置成下一个node的值，整条链表中删除下一个node就行，
            //因为node替换成下一个node的值相当于node的值已经不存在
            node.val = node.next.val;
            node.next = node.next.next;
        }
    }
}

328. Odd Even Linked List

class Solution {
    public ListNode oddEvenList(ListNode head) {
         // base case 必须写不然就会 head.next null 错误
        if(head == null || head.next == null) {
            return head;
        }
        ListNode odd = head; // odd poniter
        ListNode even = head.next; // even pointer
        ListNode evenHead = even; //pointer 指向evenlist的头部
        while(even != null && even.next != null) {
            odd.next = odd.next.next;
            odd = odd.next;
            even.next = even.next.next;
            even = even.next;
        }
        odd.next = evenHead;
        return head;
    }
}

86. Partition List

class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode lessDummy = new ListNode(0);
        ListNode cur1 = lessDummy;
        ListNode moreDummy = new ListNode(0);
        ListNode cur2 = moreDummy;
        while(head != null) {
            if(head.val < x) {
                cur1.next = head;
                cur1 =cur1.next;
            } else {
                cur2.next = head;
                cur2 = cur2.next;
            }
             head = head.next;
        }
        cur1.next = moreDummy.next;
        cur2.next = null; //要指向null 不然是环cycle
        return lessDummy.next;
    }
}

147. Insertion Sort List

class Solution {
    public ListNode insertionSortList(ListNode head) {
        ListNode dummy = new ListNode(0);
        ListNode cur = head;
        ListNode next = null;
        while(cur != null) {
            next = cur.next;
            ListNode pre = dummy;
            while(pre.next != null && pre.next.val <= cur.val) {
                pre = pre.next;
            }
            cur.next = pre.next;
            pre.next = cur;
            cur = next;
        }
        return dummy.next;
    }
}

725. Split Linked List in Parts

class Solution {
    public ListNode[] splitListToParts(ListNode head, int k) {
        ListNode[] ans = new ListNode[k];// 划分成k部分
        int len = 0;
        ListNode root = head; //需要使用pointer，不然后续head本身的值会变化
        while(root != null) {
            len++; // 计算list的总长度
            root = root.next;
        }
        int num = len / k, leftNum = len % k; // k个部分，每个部分len/k，余数leftNum则平摊到前leftNum个list中
        ListNode pre = null; //定义一个pre指针方便后面断开list
        root = head; // root重新复原到root

        for(int i = 0; root != null && i < k; i++) { //i是小于k，因为数组有k个
            ans[i] = root;
            //每个数组是listNode，计算ListNode的长度
            for(int j = 0; j < num + (leftNum > 0 ? 1 : 0); j++) {
                pre = root;
                root = root.next;
            }
            leftNum--; //一个数组也就是一个部分，一个部分走完后，leftNum➖1
            if(pre != null) {
                // 走到这里pre该断开，如果判断不为null，则断开
                pre.next = null;
            }
        }
        return ans;
    }
}

1171. Remove Zero Sum Consecutive Nodes from Linked List

class Solution {
    public ListNode removeZeroSumSublists(ListNode head) {
       
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        HashMap<Integer, ListNode> map = new HashMap();
        int sum = 0;
        map.put(0, dummy); //  this line can be deleted

       for(ListNode cur = dummy; cur != null; cur = cur.next) {
           sum += cur.val;
           map.put(sum, cur);
       }

       sum = 0;
       for(ListNode cur = dummy; cur != null; cur = cur.next) {
           sum += cur.val;
           cur.next = map.get(sum).next;
       }
        return dummy.next;
    }
}


class Solution {
    public ListNode removeZeroSumSublists(ListNode head) {
       
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        HashMap<Integer, ListNode> map = new HashMap();
        int sum = 0;
        map.put(0, dummy);

        ListNode cur = dummy;
        while(cur !=null) {
            sum += cur.val;
            map.put(sum, cur);
            cur = cur.next;
        }

        sum = 0;
        cur = dummy;
        while(cur != null) {
            sum += cur.val;
            cur.next = map.get(sum).next;
            cur = cur.next; // 忘记写了就超时
        }
        return dummy.next;
    }
}

817. Linked List Components

class Solution {
    public int numComponents(ListNode head, int[] nums) {
        HashSet<Integer> set = new HashSet(); // convert to set because set has contains method
        for(int num : nums) {
            set.add(num);
        }
        int component = 0, connect = 0;
        ListNode temp = head;
        while(temp != null) { //判断节点node是否出现在 set中，出现connect➕1
            if(set.contains(temp.val)) {
                connect += 1;
            } else if( connect > 0){ 
                // 当某个节点不出现时 判断此时connect是否大于0， 大于说明这个节点前面有component，然后讲connect重制为0
                component +=1;
                connect = 0;
            }
            temp = temp.next;
        }
        if(connect == 0) {
            //刚好等于0 说明刚好走完set
            return component;
        } // 否则说明set没有走完此时component➕1
        return component + 1;
    }
}

1019. Next Greater Node In Linked List

class Solution {
    public int[] nextLargerNodes(ListNode head) {
        // convert linkedlist to arraylist
        List<Integer> list = new ArrayList();
        while(head != null) {
            list.add(head.val);
            head = head.next;
        }
        int[] ans = new int[list.size()];
        Stack<Integer> stack = new Stack();
        for(int i = 0; i < list.size(); i++) {
            // when current element is bigger than previous one
            while(!stack.isEmpty() && list.get(i) > list.get(stack.peek())) {
                ans[stack.pop()] = list.get(i);
            }
            // when current element smaller than prevoious element
            stack.push(i);
        }
        return ans;
    }
}

148. Sort List 

class Solution {
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        // cut the list to two halves
        ListNode pre = null;
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null) {
            pre = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        // pre right is the middle node 
        pre.next = null;
        // sort the each half
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);

        // merger l1 l2
        return merge(l1, l2);
    }
    public ListNode merge(ListNode l1, ListNode l2) {
        ListNode head = new ListNode(0);
        ListNode dump = head;
        while(l1 != null & l2 != null) {
            if(l1.val < l2.val) {
                dump.next = l1;
                l1 = l1.next;
            } else {
                dump.next = l2;
                l2 = l2.next;
            }
            dump = dump.next;
        }
        if(l1 != null) {
            dump.next = l1;
        }
         if(l2 != null) {
            dump.next = l2;
        }
        return head.next;
    }
}

61.Rotate List

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if(head == null) {
            return null;
        }
        ListNode cur = head;
        int len = 1;
        while(cur.next != null) {
            cur = cur.next;
            len++;
        }
        cur.next = head;// circle list
        for(int i = 0; i < (len - k % len); i++ ) {
            cur = cur.next;
        }
        head = cur.next;
        cur.next = null;
        return head;
    }
}

203. Remove Linked List Elements

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode ff = new ListNode(-1);
        ff.next = head;
        ListNode cur = ff;
        while(cur.next != null) {
            if(cur.next.val == val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return ff.next;
    }
}

206. Reverse Linked List

class Solution {
    public ListNode reverseList(ListNode head) {
       ListNode cur = head;
       ListNode pre = null;
       while(cur != null) {
           ListNode temp = cur.next;
           cur.next = pre;
           pre = cur;
           cur = temp;
       } 
       return pre;
    }
}

21. Merge Two Sorted Lists

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode fake = new ListNode(), cur = fake;
        while(list1 != null && list2 != null) {
           if(list1.val <= list2.val) {
             cur.next = list1;  
             list1 = list1.next;
           } else {
               cur.next = list2;
               list2 = list2.next;
           }
           cur = cur.next;
       } 
       cur.next = list1 == null ? list2 : list1;
       return fake.next;
    }
}

92. Reverse Linked List II

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
       ListNode fake = new ListNode(0); 
       fake.next = head;
       ListNode p = fake;
       //断开后面节点 the start index of list here is 1 index
       for(int i = 0; i < right; i++) 
          p = p.next;
          ListNode last = p.next;
          p.next = null;
        
        //断开前面节点，要从前面断开，所以left-1
        p = fake;
        for(int i = 0; i < left - 1; i++) {
            p = p.next;
            ListNode b = p.next;
            p.next = null;
            b = reverseLinkedList(b);
        }
         p = fake;
        
         while(p.next != null) 
             p = p.next;
             p.next = b;
         
         while(p.next != null) 
             p = p.next;
             p.next = last;
         
         return fake.next;
    }
      ListNode reverseLinkedList(ListNode head) {
        ListNode cur = head;
        ListNode pre = null;
        while(cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

19. Remove Nth Node From End of List

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode fake = new ListNode();
        fake.next = head;
        ListNode slow = fake, fast = fake;
        for(int i = 1; i <= n; i++) {
            fast = fast.next;
        }
        while(fast.next != null) {
            slow = slow.next;
            fast = fast.next;
        }
        slow.next = slow.next.next;
        return fake.next;
    }
}

24. Swap Nodes in Pairs

class Solution {
    public ListNode swapPairs(ListNode head) {
       ListNode fake = new ListNode(0);
       fake.next = head;
       ListNode pre = fake;
       ListNode cur = head;
       while(cur != null && cur.next != null) {
           ListNode next = cur.next;
           pre.next = next;
           cur.next = next.next;
           next.next = cur;
           pre = cur;
           cur = cur.next;
       } 
       return fake.next;
    }
}

138. Copy List with Random Pointer

class Solution {
    public Node copyRandomList(Node head) {
        Map<Node, Node> map = new HashMap();
        Node cur = head;
        while(cur != null) {
            Node temp = new Node(cur.val);
            map.put(cur, temp);
            cur = cur.next;
        }
        cur = head;
        while(cur != null) {
            Node temp = map.get(cur);
            temp.next = map.get(cur.next);
            temp.random = map.get(cur.random);
            cur = cur.next;
        }
        return map.get(head);
    }
}

2. Add Two Numbers

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dum = new ListNode(0);
        ListNode cur = dum;
        int carry = 0;
        while(l1 != null || l2 != null || carry == 1) {
            int sum = 0;
            if(l1 != null) {
                sum += l1.val;
                l1 = l1.next;
            }
            if(l2 != null) {
                sum += l2.val;
                l2 = l2.next;
            }
            sum += carry;
            carry = sum / 10;
            ListNode node = new ListNode(sum % 10);
            cur.next = node;
            cur = cur.next;
        }
        return dum.next;
    }
}

445. Add Two Numbers II

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        l1 = reverseList(l1);
        l2 = reverseList(l2);
        ListNode head = addTwoNumbers2(l1, l2);
        head = reverseList(head);
        return head;
    }
    public ListNode addTwoNumbers2(ListNode l1, ListNode l2) {
        ListNode dum = new ListNode(-1);
        ListNode temp = dum;
        int sum = 0, carry = 0;
        while(l1 != null || l2 != null) {
            sum += ((l1 != null) ? l1.val : 0) + ((l2 != null) ? l2.val : 0);
            carry = sum / 10;
            if(carry != 0) {
                temp.next = new ListNode(sum % 10);
                sum /= 10;
            } else {
                temp.next = new ListNode(sum);
                sum = 0;
            }
            if(l1 != null) l1 = l1.next;
            if(l2 != null) l2 = l2.next;
            temp = temp.next;
        }
        if(sum != 0) temp.next = new ListNode(sum);
        return dum.next;
    }
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null) return head;
        return helper(head, null);
    }
    ListNode helper(ListNode head, ListNode newHead) {
        if(head == null) return newHead;
        ListNode next = head.next;
        head.next = newHead;
        return helper(next, head);
    }
}

2301_77651729
关注
LeetCode刷题笔记
qq_40088655的博客
10-14 1487
LeetCode刷题笔记！
Leetcode解题笔记(Linked List)
kelvinmao的博客
07-16 460
2016-07-16更新:19.Remove Nth Node From End of List Given a linked list, remove the nth node from the end of list and return its head.For example, Note: Given n will always be valid. Try to do this
【Leetcode】列表 list
最新发布
qq_45430996的博客
02-27 855
1.list.append() #在列表末尾添加一个元素list.unshift() #在列表开头添加一个元素2.list.extend() #在列表末尾添加至少一个元素3.list.insert(idx,val) #在列表任意位置添加一个元素4.切片 #通过替换的方式在列表任意位置添加至少一个元素2.list.pop(idx) #无指定位置时默认删除最后一个元素list.shift() #删除列表第一个元素3.list.remove(val) #删除和指定元素值相同的第一个元素。
leetcode刷题-list
yan57628的博客
12-01 549
1.list是collection的子接口 1）list集合中各种元素有序（添加顺序与取出顺序一致），且可以重复） 2）每个元素都有对应的顺序索引，即支持索引，每个元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号来索引元素 eg:sout(list.get(3)) 3)list 的三大实现类：Arraylist linkedlist vector 2.常用API（基本都是根据索引来操作元素） list主要方法： void add(int index,Object element)..
LeetCode习题练习(List的使用)：将数组分成和相等的三个部分
weixin_45889132的博客
03-20 202
leecode原题链接：将数组分成和相等的三个部分 题目要求： 给你一个整数数组 A，只有可以将其划分为三个和相等的非空部分时才返回 true，否则返回 false。 形式上，如果可以找出索引 i+1 < j 且满足 (A[0] + A[1] + … + A[i] == A[i+1] + A[i+2] + … + A[j-1] == A[j] + A[j-1] + … + A[A.lengt...
leetcode刷题（数组list回溯法）18—组合总和 II
qq_38754625的博客
09-10 173
40. 组合总和 II 给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用一次。 说明： 所有数字（包括目标数）都是正整数。 解集不能包含重复的组合。 class Solution { // 执行用时：20 ms, 在所有 Java 提交中击败了9.11%的用户 // 内存消耗：39.9 MB, 在所有 Java 提交中击败了77.52%的用户
Leetcode上List问题的总结（持续更新）
sipherhern的博客
07-04 477
———-检测链表是否有环，并返回环开始的节点 题目142. Linked List Cycle II Given a linked list, return the node where the cycle begins. If there is no cycle, return null. 解法：参考了leetcode的某个大神的解法。通过快慢指针。假设快指针的速度为2S,慢指针的速度
leetcode:leetcode刷题笔记
04-06
《LeetCode刷题笔记——Python篇》 在编程学习与面试准备中，LeetCode是一个备受推崇的在线平台，它提供了大量的编程题目，旨在提升解决算法问题的能力。本笔记主要聚焦于使用Python语言在LeetCode上的刷题过程，...
LeetCode刷题笔记——63. 不同路径 II
12-21
【LeetCode刷题笔记——63. 不同路径 II】 一、题目描述： 在LeetCode的第63题中，我们被要求计算一个有障碍物的网格中从左上角到右下角的不同路径数量。网格由一个二维整数数组`obstacleGrid`表示，其中1代表障碍...
谷歌师兄的leetcode刷题笔记-awesome-chatbot-list:深度学习聊天机器人资源集合Awesomechatbotresou
06-30
谷歌师兄的leetcode刷题笔记 Know a resource that isn't listed below? Feel free to create a new , or open an .Seq2seq/chatbot/聊天机器人相关资源收集列表。 在原来的chatbot-links的基础上，添加了一些更多的...
谷歌师兄的leetcode刷题笔记-dcpots:分发系统基本组件
06-30
谷歌师兄的leetcode刷题笔记#dcpots 用于分发应用程序实现的 lib 组件 (C++) ＃＃特征＃＃ 1. App framework library (base/App.hpp) 2. A non-blocked tcp socket msg event handler lib (client/server) [base/...
LeetCode List 专题
zhangkingsasa的博客
10-05 244
重头戏，链表 链表我准备刷20个easy，20 个 medium 说点个人的见解： 链表这个东西，在生产环境的代码中，很少用，因为一个不小心就搞出了空指针，比如说 Json 解析个列表啥的。所以这里我实现的话，如果能不改变链表结构，只改变 p->val 就能解决的问题，我不会改变链表结构。 前面没贴代码，这里还是贴上代码吧。 在上大学时，当时刚学C++，感觉链表特别难学，咋指都不对，可能给我留下点儿阴影哈哈哈。 写了半年的Go，回到写 leetcode, 还是得用 C++ ... 分..
Python Leetcode_list
yake1965
10-02 607
434. 字符串中的单词数 方法一：split class Solution: def countSegments(self, s: str) -> int: return len(s.split()) 方法二：标记 class Solution: def countSegments(self, s: str) -> int: res = 0 flag = True for c in s:
LeetCode 25
only_do_IT
04-25 1378
怪不得很多人都说LeetCode上的题好，我知道原因了，LeetCode上的题扩展性真的很高，相同的情况的不同变形，这真的会让你掌握了这类型的题的做法，我想每种类型的题做了好几个的时候，人的印象就会深刻很多，思维的严密性也会增强很多。这道题的意思我想大家通过题目给的例子应该很快就能理解吧。我就拿这道题和上一道题来对比一下，上道题中每次交换的只有两个节点，而这道题的节点数是k个。两者具体的差别如下：
[LeetCode刷题笔记] 关于LeetCode的前言
热门推荐
tostq的专栏
07-22 2万+
又到了一年毕业就业季了，三年前的校招季我逃避了，可这一次终于还是要轮到我了=_=||。 作为要准备踏入码农行业的人来说，要准备校招，怎么能不去刷刷LeetCode呢？ LeetCode收录了许多互联网公司的算法题目，被称为刷题神器，我虽然早有耳闻，不过却一直没有上面玩过。即使这一年多来，做的编程还是挺多的，不过毕竟不是计算机专业的科班出身，在编程过程中土路子实在太多了，有时不仅写得煎熬，而且书写很多时候都非常不规范。所以就决定在找工作前夕，花点时间好好刷刷LeetCode。1、熟悉各互联网公司的算法题目，为
【LeetCode】Partition List 解题报告
跳出温水的青蛙
12-12 7296
【题目】 Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. You should preserve the original relative order of the nodes
leetcode list链表练习题（一）
u014031563的博客
03-04 297
链表的数据结构 /** Definition for singly-linked list. public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } */ leetcode 2.两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存...
【LeetCode30】找出所有list的无序组合 //第一次击败89%的人，自我感觉解决思路不错
朱铭德的博客
02-20 893
LeetCode30， Substring with Concatenation of All Words
leetcode-list
你越努力，你的运气就会越好
09-18 754
自己整理一下leetcode的list. jf
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值