labuladong算法小抄-链表双指针-leetcode2、leetcode19、leetcode21、leetcode23、leetcode25、83、92、141、142、160、234、876

最新推荐文章于 2024-10-07 14:53:51 发布
最新推荐文章于 2024-10-07 14:53:51 发布
阅读量176 收藏
点赞数
分类专栏： # labuladong刷题 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41593124/article/details/125947221
版权

1.链表双指针

1.1 思想

用双指针模拟链表比遍历

2.例题

 leetcode2

 

/**
 * 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 res = new ListNode();
        res.next = null;
        ListNode tail = res;
        boolean jinwei = false;
        while(l1!=null||l2!=null){
            if(l1==null){
                int tep = l2.val;
                if(jinwei){
                    tep++;
                    jinwei = false;
                }
                if(tep >= 10){
                    jinwei = true;
                    tep %=10;
                }
                ListNode temp = new ListNode(tep);
                temp.next = null;
                tail.next = temp;
                tail = temp;

                l2=l2.next;
            }else if(l2==null){
                int tep = l1.val;
                if(jinwei){
                    tep++;
                    jinwei = false;
                }
                if(tep >= 10){
                    jinwei = true;
                    tep %=10;
                }
                ListNode temp = new ListNode(tep);
                temp.next = null;
                tail.next = temp;
                tail = temp;
                 l1=l1.next;
            
            }else {
                int tep = l1.val+l2.val;
                if(jinwei){
                    tep++;
                    jinwei = false;
                }
                if(tep >= 10){
                    jinwei = true;
                    tep %=10;
                }
                ListNode temp = new ListNode(tep);
                temp.next = null;
                tail.next = temp;
                tail = temp;
                l1=l1.next;
                l2=l2.next;
            }
        }
         if(jinwei){
                ListNode temp = new ListNode(1);
                temp.next = null;
                tail.next = temp; 
                }
        return res.next;
    }
}

leetcode19

/**
 * 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) {
        ListNode res = new ListNode();
        res.next = head;
        ListNode tail = res;
        ListNode h1 = res;
        while(n!=0){
            tail = tail.next;
            n--;
        }
        while(tail.next !=null){
            tail = tail.next;
            h1 = h1.next;
        }
        h1.next = h1.next.next;
        return res.next;
    }
}

 

leetcode21

/**
 * 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 res = new ListNode();
        res.next = null;
        ListNode tail = res;
        while(list1!=null|list2!=null){
            if(list1==null){
                ListNode tep = list2;
                list2 = list2.next;
                tep.next =null;
                tail.next = tep;
                tail = tep;
            }else if(list2==null){
                 ListNode tep = list1;
                list1 = list1.next;
                tep.next =null;
                tail.next = tep;
                tail = tep;
            }else if(list1.val>list2.val){
                ListNode tep = list2;
                list2 = list2.next;
                tep.next =null;
                tail.next = tep;
                tail = tep;
            }else{
                 ListNode tep = list1;
                list1 = list1.next;
                tep.next =null;
                tail.next = tep;
                tail = tep;
            }
        }
        return res.next;
    }
}

 

leetcode23

/**
 * 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 mergeKLists(ListNode[] lists) {
        ListNode res = new ListNode();
        res.next =null;
        ListNode tail = res;
        boolean flag = true;
        int index = -1;
        while(flag){
          for (int i=0,ilen=lists.length;i<ilen;i++){
              if(lists[i]!=null){
                  if(index == -1){
                      index = i;
                  }else {
                      if(lists[i].val < lists[index].val){
                          index = i;
                      }
                  }
              }
          }
          if(index == -1){
              flag = false;
          }else {
              ListNode tep = lists[index];
              lists[index]=lists[index].next;
              tep.next =null;
              tail.next = tep;
              tail = tep;
          }
          index = -1;
        }
        return res.next;
    }
}

 

leetcode25

 

/**
 * 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 reverseKGroup(ListNode head, int k) {
        ListNode res = new ListNode();
        res.next = null;
        ListNode tail = res;
        // 双指针
        ListNode p1 = head;
        ListNode p2 = head;
        // 记录
        int cv = 1;
        if(p1==null)cv =0;
        while(p2!=null){
            if(cv == k){
                head = p2.next;
                p2.next = null;
                ListNode tep= reverse(p1);
                tail.next = tep;
                tail = p1;
                p1 = head;
                p2 = head;
                if(p1 == null)cv=0;
                else cv =1;
            }
            if(p2 == null)break;
            p2=p2.next;
            cv ++;
        }
        if(cv!=0){
            tail.next = p1;
        }
        return res.next;
    }
    public ListNode reverse(ListNode head){
        ListNode res = new ListNode();
        res.next = null;
        while(head!=null){
            ListNode tep = head;
            head=head.next;
            tep.next = res.next;
            res.next = tep;
        }
        return res.next;
    }
}

leetcode83

/**
 * 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) {
        HashSet<Integer> set = new HashSet<>();
        ListNode res =new ListNode();
        res.next = head;

        ListNode h1=res,h2=head;
        while(h2!=null){
            if(set.contains(h2.val)){
                h1.next = h2.next;
                h2=h1.next;
            }else{
                set.add(h2.val);
                   h1=h1.next;
                   h2=h2.next;
            }
        }
        return res.next;
    }
}

 

leetcode92

/**
 * 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 res = new ListNode();
        res.next = head;
        ListNode p1=res,p2=null,p3=null,p4=null;
        int index =1;
        while(head!=null){
            if(index == left -1){
                p1 = head;
            }
            if(index == left){
                p2 = head;
            }
            if(index == right){
                p3 = head;
                p4 = head.next;
            }
            index++;
            head=head.next;
        }
        
        p3.next = null;
        reverse(p2);
        p1.next = p3;
        p2.next = p4;
        return res.next;
    }
    public ListNode reverse(ListNode head){
        ListNode res =new ListNode();
        res.next = null;
        while(head!=null){
            ListNode tep = head;
            head=head.next;
            tep.next = res.next;
            res.next = tep;

        }
        return res.next;
    }
}

 

leetcode141

 

/**
 * 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) {
        HashSet<ListNode> set = new HashSet<>();
        while(head!=null){
            if(set.contains(head)){
                return true;
            }
            else {
                set.add(head);
            }
            head= head.next;
        }
        return false;
    }
}

leetcode142

 

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        HashSet<ListNode> hashset = new HashSet<>();

        while(head!=null){
            if(hashset.contains(head)){
                return head;
            }else {
                hashset.add(head);
            }
            head=head.next;
        }
        return null;
    }
}

leetcode160

/**
 * 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 count = 0;
        ListNode h1 = headA;
        ListNode h2 = headB;
        while(headA!=null || headB != null){
            if(headB == headA) return headA;

            headA = headA.next;

            headB = headB.next;

            if(headA == null){
                headA = h2;
                count++;
            }
            if(headB == null){
                headB = h1;
                count++;
            }
            if(count == 2){
                break;
            }
        }
        while(headA!=null && headB != null){
            if(headB == headA) return headA;

            headA = headA.next;

            headB = headB.next;

            
        }
        return null;
    }
}

leetcode234

 

/**
 * 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) {
        int sum = 0;
        ListNode h1 = head;
        while(h1!=null){sum++;h1=h1.next;}
        int right = 0;
        if(sum%2==0){
            right = sum / 2 +1;
        }else{
            right = sum / 2 +2;
        }
        ListNode h2 = null;
        h1 = head;
        int index =1;
        while(h1 !=null){
            if(index == right){
                h2 = h1;
                break;
            }
            index++;
            h1=h1.next;
        }
        h2 = reverse(h2);
        h1 = head;
        while(h1!=null&&h2!=null){
            if(h1.val!=h2.val){
                return false;
            }
              h1=h1.next;
             h2=h2.next;
        }

        return true;
    }
    public ListNode reverse(ListNode head){
        ListNode res = new ListNode();
        res.next = null;
        while(head!=null){
            ListNode tep = head;
            head = head.next;
            tep.next = res.next;
            res.next = tep;
        }
        return res.next;
    }
}

leetcode876

 

/**
 * 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 middleNode(ListNode head) {
        ListNode h1 = head;
        ListNode h2 = head;
        if(head.next == null)return head;
        while(h1!=null&&h2!=null){
                h1 = h1.next;
                h2 = h2.next;
                if(h2.next==null){
                    return h1;
                }else{
                    h2 = h2.next;
                }
                if(h2.next == null)break;
        }
        return h1;

    }
}

阿联爱学习
关注
专栏目录
019、双指针刷链表（labuladong）
Yora123的博客
01-08 66
labuladong的双指针技巧秒杀七道链表题目
双指针技巧直接秒杀五道算法题
fdl123456的博客
11-05 341
学算法认准labuladong后台回复进群一起刷力扣????读完本文，可以去力扣解决如下题目：141.环形链表（Easy）141.环形链表II（Medium）167.两数之和 II -...
labuladong双指针技巧秒杀七道数组题目
Fxxkke的博客
03-01 300
labuladong双指针技巧秒杀七道数组题目
labuladong算法学习二:链表双指针技巧全面汇总
Bruce
06-30 210
不过注意我们又使用了虚拟头结点的技巧，也是为了防止出现空指针的情况，比如说链表总共有 5 个节点，题目就让你删除倒数第 5 个节点，也就是第一个节点，那按照算法逻辑，应该首先找到倒数第 6 个节点。具体来说，我们可以把原链表分成两个小链表，一个链表中的元素大小都小于 x，另一个链表中的元素都大于等于 x，最后再把这两条链表接到一起，就得到了题目想要的结果。就是这个题目，问题的关键也在于我们无法直接得到单链表的长度 n，常规方法也是先遍历链表计算 n，再遍历一次得到第 n / 2 个节点，也就是中间节点。
labuladong刷题——第一章（1） 双指针技巧秒杀七道链表题目
qq_37772958的博客
09-13 381
双指针技巧秒杀七道链表题目
算法学习笔记Day2——双指针技巧之单链表
m0_61940795的博客
04-06 1653
i). 链表的尽头判断是用 List!= nullprt，而不是List->next!ii). 拼接最后的部分不需要用两个while，直接把节点的结构体赋值过去就可以了。iii). C++中所有NULL都用nullptr代替，为了迎合C++的重载特性。（*NULL 在C++ 里表示。
双指针的妙用，巧解一道高频面试题：接雨水
程序员吴师兄的博客
09-09 860
点击蓝色“五分钟学算法”关注我哟加个“星标”，天天中午 12:15，一起学算法作者 | labuladong来源 | labuladong接雨水这道题目挺有意思，在面试题...
力扣方法总结：双指针
南航小菜鸡
05-22 243
本文部分内容参考 https://labuladong.github.io/algo/2/18/21/ 双指针技巧主要分为两类：左右指针和快慢指针。 所谓左右指针，就是两个指针相向而行或者相背而行；而所谓快慢指针，就是两个指针同向而行，一快一慢。 26. 删除有序数组中的重复项 Easy 双指针-快慢指针 2022/5/18 给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。 示例： 输入：
数组双指针直接秒杀七道题目
fdl123456的博客
03-23 880
学算法认准labuladong后台回复打卡参与刷题挑战读完本文，可以去力扣解决如下题目：26. 删除有序数组中的重复项（简单）83. 删除排序链表中的重复元素（简单）167. 两数之和 II - 输入有序数组（中等）27. 移除元素（简单）283. 移动零（简单）344. 反转字符串（简单）5. 最长回文子串（中等）双指针技巧在处理数组和链表相关问题时经常用到，主要分为...
labuladong算法小结
热门推荐
limx的博客
06-30 1万+
1. 数据结构的存储方式 2. 数据结构基本操作——遍历+访问 线性 ​ for/while void traverse(int[] arr) { for (int i = 0; i < arr.length; i++) { // 迭代访问 arr[i] } } 非线性 ​ 递归 链表遍历框架 兼具迭代和递归结构: class ListNode{ int val; ListNode next; } void traverse(ListNod
LeetCode5. 最长回文子串647. 回文子串（双指针、中心扩展算法）
IOT_victor的博客
05-06 321
1、题目描述 给定一个字符串s，找到s中最长的回文子串。你可以假设s的最大长度为 1000。 2、代码详解 class Solution(object): def longestPalindrome(self, s): res = "" for i in range(len(s)): # 法一 ...
算法学习之双指针(java版)
striver 13
07-10 5390
算法学习之双指针(java版) 数组或字符串相关的问题经常需要运用双指针来求解。而双指针又分为快慢指针和左右指针。其中快慢指针主要用于解决链表问题，而左右指针用于解决数组问题。 概念 快慢指针 顾名思义，快慢指针是指一个指针走的快，一个指针走得慢。 左右指针 左右指针是指双指针中一个指针在数组的最左侧，而另一个在最右侧。通过判断，可以分别让两侧的指针向中间移动，以求解问题。 例题 判断链表是否有环（快慢指针） 思路：快指针每次走两步，慢指针每次走一步。如果链表中存在环，总有那么一个时刻快指针比慢指针多走
双指针算法技巧的「滑动窗口」框架
汐客SeaKr的博客
11-19 395
题目案例： 最小覆盖子串 - lua实现 找到字符串中所有字母异位词 - lua实现 无重复字符的最长子串 - lua实现 滑动窗口算法思路： 1、我们在字符串 S 中使用双指针中的左右指针技巧，初始化 left = right = 0，把索引闭区间 [left, right] 称为一个「窗口」。 2、我们先不断地增加 right 指针扩大窗口 [left, right]，直到窗口中的...
【笔记】数据结构12
m0_52024881的博客
09-29 623
看到的社区的一个知识总结，这里记录一下。
数据结构--二叉树的顺序实现（堆实现）
2302_81410974的博客
10-04 1233
在计算机科学中，二叉树是一种重要的数据结构，广泛应用于各种算法和程序设计中。本文将探讨二叉树的顺序实现，特别是堆的实现方式。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1216
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
【数据结构】【栈】算法汇总
Indigo____的博客
10-07 146
【代码】【数据结构】【栈】算法汇总。
信息学奥赛复赛复习14-CSP-J2021-03网络连接-字符串处理、数据类型溢出、数据结构Map、find函数、substr函数
最新发布
ya888g
10-07 822
如果某台提供符合规范的地址的客户机在尝试加入连接时，与先前某台已经成功建立连接的服务机提供的地址串相同，这台客户机就可以成功加入连接，并称其连接到这台服务机；服务机提供的地址串表示它尝试建立连接的地址，客户机提供的地址串表示它尝试加入连接的地址。请注意，尽管不允许两台不同的服务机使用相同的地址串，但多台客户机使用同样的地址串，以及同一台服务机同时被多台客户机连接的情况是被允许的。需要进行网络连接的计算机共有 n 台，编号为 1∼n，这些机器将按编号递增的顺序，依次发起一条建立连接或加入连接的操作。
数据结构（链表的操作算法）
m0_61903191的博客
09-30 574
编写一个程序exp2_2.cpp,采用单链表表示集合(假设同一个集合中不存在重复素)，将其按递增方式排序，构成有序单链表，并求这样的两个集合的并、交和差。(2)依次采用尾插法插入a、b、c、d、e元素。(8)在第4个元素位置上插人1元素。(10)删除单链表h的第3个元素。(6)输出单链表h的第3个元素。(5)判断单链表h是否为空。(4)输出单链表h长度。(7)输出元素a的位置。(1)初始化单链表h。(11)输出单链表h。(12)释放单链表h。(3)输出单链表h。(9)输出单链表h。
labuladong算法小抄：动态规划与数据结构详解
labuladong的《算法小抄完整版》是一本深入浅出的编程算法学习资料，主要涵盖多个核心算法和数据结构主题，旨在帮助读者理解和掌握常见的IT面试技巧和解决实际问题的方法。以下是部分内容的详细解读： 1. **章节...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿联爱学习

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值