Letcode-Top 100链表专题

已于 2023-02-10 15:12:53 修改
阅读量201 收藏
点赞数
分类专栏： LetCode Top100 文章标签： 链表 算法 数据结构
于 2023-02-10 13:40:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43170213/article/details/128968646
版权

《链表专题》

1.简单 合并两个有序链表

在这里插入图片描述
1.使用类似归并的算法

/**
 * 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 mergeTwoLists(ListNode list1, ListNode list2) {
        // 首先新建一个链表
        ListNode newList = new ListNode(0);
        ListNode pre = newList;
        if(list1==null){
            newList.next = list2;
        }

        if(list2==null){
            newList.next = list1;
        }

        while(list1!=null&&list2!=null){
            
            if(list1.val<list2.val){
                newList.next = list1;
                list1 = list1.next;
            }else{
                newList.next = list2;
                list2 = list2.next;
            }
            newList = newList.next;
        }

        if(list1!=null){
            newList.next = list1;
        }

        if(list2!=null){
            newList.next = list2;
        }


        return pre.next;

    }
}

2.递归方法(核心是递归方程)
在这里插入图片描述

/**
 * 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 mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1==null){
            return list2;
        }else if(list2==null){
            return list1;
        }else if(list1.val>list2.val){
            list2.next = mergeTwoLists(list1,list2.next);
            return list2;
        }else{
            list1.next = mergeTwoLists(list1.next,list2);
            return list1;
        }

    }
}

2. 简单 环形链表

在这里插入图片描述
1.暴力破解，超级无敌经典的方法

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {

        int count = 0;


        while(count<100000&&head!=null){
           head = head.next;
           count++;
        }

        return count<100000?false:true;
        
    }
}

2.快慢指针

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {


        ListNode fast = head;
        ListNode slow = head;

        while(fast!=null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast==slow){
                return true;
            }
        }

        return false;
        
    }
}

3.HashSet特性

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> set = new HashSet<ListNode>();
        while(head!=null){
            if(!set.add(head)){
                return true;
            }
            head = head.next;
        }
        return false;
    }
}

3. 简单 相交链表

在这里插入图片描述

1.经典写法

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int countA = 0;
        int countB = 0;

        ListNode a = headA;
        ListNode b = headB;

        while(a!=null){
            countA++;
            a = a.next;
        } 

        while(b!=null){
            countB++;
            b = b.next;
        }

        int result = Math.abs(countA-countB);

        if(countA>countB){
           for(int i=0;i<result;i++){
               headA = headA.next;
           }
        }

        if(countA<countB){
           for(int i=0;i<result;i++){
               headB = headB.next;
           }
        }

        while(headA!=null&&headB!=null){
            if(headB==headA){
                return headA;
            }
            headA = headA.next;
            headB = headB.next;
        }

        return null;
    }
}

2.使用Set集合

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        Set<ListNode> set = new HashSet<ListNode>();

        while(headA!=null){
            set.add(headA);
            headA = headA.next;
        }

        while(headB!=null){
            if(set.contains(headB)){
                return headB;
            }
            headB= headB.next;
        }

        return null;
    }
}

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

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA==null||headB==null){
            return null;
        }

        ListNode pA = headA;
        ListNode pB = headB;

        while(pA!=pB){
            pA = (pA == null?headB:pA.next);
            pB = (pB == null?headA:pB.next);
        }
        return pA;
    }
}

4. 简单 反转链表

在这里插入图片描述

1.头插法

class Solution {
    public ListNode reverseList(ListNode head) {

        ListNode newhead = new ListNode(0);
        ListNode curNode = head;
        while(curNode!=null){
            ListNode temp = curNode.next;
            curNode.next = newhead.next;
            newhead.next = curNode;
            curNode = temp;

        }

        return newhead.next;


    }
}

2.迭代插入法

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head; 

        while(cur!=null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre =cur ;
            cur = temp;
        }
        return pre;
    }
}

5. 简单 回文链表

在这里插入图片描述
1.传统的栈方法

import java.util.Stack;
class Solution {
   public static boolean isPalindrome(ListNode head) {

            Stack<ListNode> stack = new Stack<>();

            int totalCount = 0;
            ListNode cur = head;
            while(cur!=null){
                totalCount++;
                cur = cur.next;
            }
            if(totalCount<2){
                return true;
            }

            // 判断奇偶
            if(totalCount%2==0){
                int i = 0;
                while(head!=null){
                    if(i<(totalCount/2)){
                        stack.push(head);
                    }else{
                        ListNode temp = stack.pop();
                        if(head.val!=temp.val){
                            return false;
                        }
                    }
                    head = head.next;
                    i++;
                }

            }else if(totalCount%2==1){
                int i = 0;
                while(head!=null){
                    if(i<(totalCount/2)){
                        stack.push(head);
                    }else if(i==totalCount/2){
                        // 不用处理
                    }else{
                        ListNode temp = stack.pop();
                        if(head.val!=temp.val){
                            return false;
                        }
                    }
                    head = head.next;
                    i++;
                }
            }

            return true;

        }
}

2.精简版本的栈

import java.util.Stack;
class Solution {
   public static boolean isPalindrome(ListNode head) {

            Stack<ListNode> stack = new Stack<>();
            ListNode cur = head;
            while(cur!=null){
                stack.push(cur);
                cur = cur.next;
            }

            while(head!=null){
                if(head.val!=stack.pop().val){
                    return false;
                }
                head = head.next;
            }

            return true;
        }
}

6. 中等 链表相加

在这里插入图片描述
两数相加思路是相对简单的，但是最后一位的处理容易遗漏

/**
 * 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 addTwoNumbers(ListNode l1, ListNode l2) {
            // 循环获取数据
            ListNode node = new ListNode(0);
            ListNode resultNode = node;
            ListNode ll1 = l1;
            ListNode ll2 = l2;
            int high = 0;
            int low  = 0;
            int sum  = 0;
            while(ll1!=null||ll2!=null){

                if(ll1!=null&&ll2!=null){
                    sum = ll1.val + ll2.val + high;
                }
                if(ll1==null&&ll2!=null){
                    sum = ll2.val + high;
                }
                if(ll1!=null&&ll2==null){
                    sum = ll1.val + high; 
                }
                if(ll1==null&&ll2==null){
                    sum = 0 + high;
                }
                if(ll1!=null){
                    ll1=ll1.next;
                }
                if(ll2!=null){
                    ll2=ll2.next;
                }
                high = sum/10;
                low  = sum%10;
              
                ListNode tempNode = new ListNode(low);
                resultNode.next = tempNode;
                resultNode = resultNode.next;
            }

            if(high>0){
                ListNode tempNode = new ListNode(high);
                resultNode.next = tempNode;
                resultNode = resultNode.next;
            }

            return node.next;
    }
}

7 删除链表的倒数第N个节点

在这里插入图片描述
1.对单链表增加一个头指针，然后求出对应的位置

/**
 * 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) {
        // 删除链表的倒数第N个节点
        // 先统计链表的数量
        ListNode node = head;
        ListNode newHead = new ListNode(0);
        newHead.next = head;
        ListNode newNode = newHead;

        int total = 0;
        while(node!=null){
            total++;
            node = node.next;
        }

        if(total==0){
            return head;
        }

        for(int i=0;i<total-n;i++){
            newHead = newHead.next;
        }

        newHead.next = newHead.next.next;
        return newNode.next;
    }

}

2.快慢指针，快指针先走k步

/**
 * 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) {
        // 快慢指针
        // 快指针先走k步，慢指针再开始一块走 

        ListNode node = new ListNode(0);
        node.next = head;

        ListNode fast = head;
        ListNode slow = node;

        int i=0;
        while(i<n){
            fast = fast.next;
            i++;
        }

        // 快慢指针一块走 
        while(fast!=null){
            fast = fast.next;
            slow = slow.next;
        }
        
        slow.next = slow.next.next;

        return node.next;

    }
}
丘山一郎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
leetcode-86 分隔链表
01-08
给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。 你应当保留两个分区中每个节点的初始相对位置。 示例: 输入: head = 1->4->3->2->5->2, x = 3 输出: 1->2->2->4-...
leetcode跳跃-leetcode-top:leetcode-top
06-30
leetcode-top 记录使用 C++ 刷 leetcode 可使用浏览器页面搜索功能「Ctrl + F / Command + F」 定位题目 进度 点击题号 跳转leetcode 点击题目 跳转解法 题号 题目 难度 备注 easy medium medium medium medium ...
leetcode-top100链表专题一
weixin_53908842的博客
02-01 469
我们在起点放置一个指针，在结尾放置一个指针，每一次迭代判断两个指针指向的元素是否相同，若不同，则返回false;相同则将两个指针向内移动，并继续判断，直至两个指针相遇。每次迭代向数组添加currentNode.val，并更新currentNode = currentNode.next，当currentNode = null时停止循环。在编码的过程中，注意我们比较的时节点值的大小，而不是节点本身，正确的比较方式是，node1.val == node2.val，而不是node1 == node2。
leetcode-top100链表专题二
最新发布
weixin_53908842的博客
02-02 239
【代码】leetcode-top100链表专题二。
leetcode-二叉树专题
apple_53406386的博客
05-14 258
【代码】leetcode-二叉树专题
LeetCode 链表专题
karry_zzj的博客
06-01 189
这是整理的LeetCode上的链表专题，按照codeTop上的频率顺序从高到低进行整理。
Leetcode--剑指Offer
qq_61688804的博客
08-12 744
刷题记录
leetcode算法题主函数如何写-leetcode-top_100:leetcode-top_100
06-30
leetcode-top_100 1. 两数之和 问题：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用...
zwangZJU#LeetCode-in-python-wznote#LeetCode-python-83-删除排序链表中的重复
07-25
示例1输入: 1->1->2输出: 1->2示例2输入: 1->1->2->3->3输出: 1->2->3解题思路如果当前节点的值和下一个节点的值相等，则当前节
leetcode怎么销号-LeetCode-Top-Interview-Questions:LeetCode-Top-Interview-Qu
06-30
leetcode怎么销号 LeetCode便签 Linked List Cycle 问题描述 Given a linked list, determine if it has a cycle in it. Follow up:Can you solve it without using extra space? 解决思路 声明一个慢指针和一个快...
Letcode-Top 100 简单题目
qq_43170213的博客
10-22 637
letcode top 100
推荐结果打散 （快手面试题目） 用两个队列
qq_43170213的博客
01-18 274
public List<String> getRecommendenResult(List<String> picAndVideo,int maxInterval){ List<String> result=new ArrayList<>(); if(picAndVideo==null || picAndVideo.size()==0){ return result; } Queue<String>.
最小栈 Min_Stack
qq_43170213的博客
01-17 263
最小栈，一定要读懂题目 class MinStack { /** initialize your data structure here. */ Stack<Integer> stack; Stack<Integer> minStack; public MinStack() { stack=new Stack(); minStack=new Stack(); } public void pu.
BFS-DFS-回溯-递归 （通俗易懂版）
qq_43170213的博客
08-19 258
DFS BFS 回溯 递归
Letcode动态规划专题-困难
qq_43170213的博客
09-18 219
Letcode动态规划专题-困难
链表反转I，链表反转II（从m到n位置）
qq_43170213的博客
01-16 195
链表反转I /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode ReverseList(ListNode head) { if(head==null||head.next==null){
字节跳动 区间最大值 牛客网
qq_43170213的博客
01-18 175
核心的思想是：栈+前缀和 public int getMax(int[] numbers){ if(numbers.length==0||numbers==nul){ return 0; } Stack<Integer> stack=new Stack<>(); int max=0; //求前缀和的数组 int[] sum=new int[numbers.length+1]; for(int i=1;i&.
560. 和为K的子数组
qq_43170213的博客
01-25 169
方法一：暴力破解的方法 class Solution { public int subarraySum(int[] nums, int k) { if(nums==null||nums.length==0){ return 0; } int sum=0; int count=0; for(int i=0;i<nums.length;i++){ for(int j=.
leetcode-5:实现链表的首尾链接
12-30
leetcode-5题要求我们实现链表的首尾链接，即将链表中最后一个节点的next指针指向链表中的第一个节点，并将链表中的第一个节点的prev指针指向链表中最后一个节点。 解题思路如下： 1. 首先，判断链表是否为空，若为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值