break algorithm---双指针1：快慢指针

已于 2022-06-14 17:27:30 修改
阅读量1k 收藏
点赞数
文章标签： 算法
于 2022-04-15 17:56:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41875506/article/details/124133395
版权

😡😡😡

声明：
算法基于https://labuladong.github.io/
同步git地址：https://github.com/muxintong/break-algorithm/
python语言实现

双指针解决如下问题：
快慢指针：链表、归并排序找中点
list-to-linkedlist template
19. Remove Nth Node From End of List
21. Merge Two Sorted Lists
876. Middle of the Linked List
26. Remove Duplicates from Sorted Array
160. Intersection of Two Linked Lists
27. Remove Element
linkedlist-has-circle

😡😡😡


快慢指针：链表、归并排序找中点


list-to-linkedlist template

python:

from typing import Optional


class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next


def list2link(list_):
    head = ListNode(list_[0])
    p = head
    for i in range(1, len(list_)):
        p.next = ListNode(list_[i])
        p = p.next

    return head


def print_link_list(head: Optional[ListNode]) -> Optional[ListNode]:
    p = head
    while p:
        print(p.val)
        p = p.next
    return head


if __name__ == "__main__":
    old_list = [1, 2, 3, 4, 5]
    link = list2link(old_list)
    # Input: list1 = [1,2,4], list2 = [1,3,4]
    # Output: [1,1,2,3,4,4]
    # list1 = [1, 2, 4]
    list2 = [1, 3, 4]
    # link1 = list2link(list1)
    link2 = list2link(list2)
    print_link_list(link2)

linkedlist-has-circle template

python

"""
链表成环判定：使用双指针中的快慢指针解决
procedure：
每当慢指针 slow 前进一步，快指针 fast 就前进两步。

如果 fast 最终遇到空指针，说明链表中没有环；
如果 fast 最终和 slow 相遇，那肯定是 fast 超过了 slow 一圈，说明链表中含有环。
"""
from typing import Optional


class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next


# 链表成环判定：快慢指针技巧，含环返回True，不含返回False
def linkedlist_hasCircle(head: Optional[ListNode]) -> bool:
    fast = head
    slow = head
    # 终止条件：快指针走到末尾时停止
    while fast and fast.next:
        # 过程：快走两步，慢走一步，若此过程中二者相遇则说明链表含环
        slow = slow.next
        fast = fast.next.next
        if fast == slow:
            return True

    return False


# 含环链表返回环起点
def linkedlist_circle_point(head: Optional[ListNode]) -> Optional[ListNode]:
    fast = head
    slow = head
    # 成环判定：快两步，慢一步，二者相等时即含环
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        # 【相遇点】快慢指针相遇=>含环=>在快慢指针相遇点终止循环
        if slow == fast: break

    if fast == None or fast.next == None:
        # fast与空指针说明无环
        return None

    # 【环起点】使慢指针重新指向链表头，二者同步前进，再次相交点就是环起点
    slow = head
    while slow != fast:
        slow = slow.next
        fast = fast.next

    return slow

19. Remove Nth Node From End of List

https://leetcode.com/problems/remove-nth-node-from-end-of-list/

from typing import Optional


# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        # NOTE:虚拟头结点的使用，否则对于特殊边界情况需特殊处理
        dummy = ListNode(-1)
        dummy.next = head
        # Note:删除节点n时需找到节点n的前驱，由于是倒数，故其前一个节点是n+1，而不是n-1
        precusor_n = self.findNthFromEnd(dummy, n + 1)
        precusor_n.next = precusor_n.next.next
        return dummy.next

    def findNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        p1 = head
        for i in range(n):
            p1 = p1.next

        p2 = head
        while p1:
            p1 = p1.next
            p2 = p2.next

        return p2


def list2link(list_):
    head = ListNode(list_[0])
    p = head
    for i in range(1, len(list_)):
        p.next = ListNode(list_[i])
        p = p.next

    return head


def print_link_list(head: Optional[ListNode]) -> Optional[ListNode]:
    p = head
    while p:
        print(p.val)
        p = p.next
    return head


def main():
    # Input: head = [1,2,3,4,5], n = 2
    # Output: [1,2,3,5]
    solution1 = Solution()
    head = solution1.removeNthFromEnd(list2link([1, 2, 3, 4, 5]), 2)
    print_link_list(head)

    print('---')

    # Input: head = [1], n = 1
    # Output: []
    solution2 = Solution()
    head = solution2.removeNthFromEnd(list2link([1]), 1)
    print_link_list(head)

    print('---')

    # Input: head = [1, 2], n = 2
    # Output: [2]
    solution3 = Solution()
    head = solution3.removeNthFromEnd(list2link([1, 2]), 2)
    print_link_list(head)

    print('---')

    # Input: head = [1,2], n = 1
    # Output: [1]
    solution4 = Solution()
    head = solution4.removeNthFromEnd(list2link([1, 2]), 1)
    print_link_list(head)


if __name__ == '__main__':
    main()

21. Merge Two Sorted Lists

https://leetcode.com/problems/merge-two-sorted-lists/

from typing import Optional


# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode(-1)
        p = dummy
        p1 = list1
        p2 = list2

        while p1 and p2:
            if p1.val > p2.val:
                p.next = p2
                p2 = p2.next
            else:
                p.next = p1
                p1 = p1.next
            p = p.next
        if p1:
            p.next = p1
        if p2:
            p.next = p2

        return dummy.next

    def print(self, head: ListNode):
        p = head
        while p:
            print(p.val)
            p = p.next


def list2link(list_):
    if list_:
        head = ListNode(list_[0])
        p = head

        for i in range(1, len(list_)):
            p.next = ListNode(list_[i])
            p = p.next

    return head


def main():
    # Input: list1 = [1,2,4], list2 = [1,3,4]
    # Output: [1,1,2,3,4,4]
    list1 = [1, 2, 4]
    list2 = [1, 3, 4]
    link1 = list2link(list1)
    link2 = list2link(list2)
    solution1 = Solution()
    head1 = solution1.mergeTwoLists(link1, link2)
    solution1.print(head1)


if __name__ == '__main__':
    main()

23. Merge k Sorted Lists

https://leetcode.com/problems/merge-k-sorted-lists/

from typing import Optional, List


# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        arr = []
        for member in lists:
            while member:
                arr.append(member.val)
                member = member.next

        arr.sort()

        res = ListNode(-1)
        p = res
        for i in arr:
            p.next = ListNode(i)
            p = p.next
            print(p.val)

        return res.next


def list2link(list_):
    head = ListNode(list_[0])
    p = head
    for i in range(1, len(list_)):
        p.next = ListNode(list_[i])
        p = p.next

    return head


def main():
    # Input: lists = [[1,4,5],[1,3,4],[2,6]]
    # Output: [1,1,2,3,4,4,5,6]
    # Explanation: The linked-lists are:
    # [
    #   1->4->5,
    #   1->3->4,
    #   2->6
    # ]
    # merging them into one sorted list:
    # 1->1->2->3->4->4->5->6
    solution1 = Solution()
    solution1.mergeKLists([list2link([1, 4, 5]), list2link([1, 3, 4]), list2link([2, 6])])

    print('---')

    # Input: lists = []
    # Output: []
    solution2 = Solution()
    solution2.mergeKLists([])

    print('---')

    # Input: lists = [[]]
    # Output: []
    solution3 = Solution()
    solution3.mergeKLists([[]])


if __name__ == '__main__':
    main()

876. Middle of the Linked List

https://leetcode.com/problems/middle-of-the-linked-list/

from typing import Optional


# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 快慢指针的使用：
        # 二者同时从头出发，快指针每次前进两步，慢指针每次前进一步，
        # 当快指针到达链表尾部时，慢指针正好到达链表中点。
        fast = head
        slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next

        return slow


def list2link(list_):
    head = ListNode(list_[0])
    p = head
    for i in range(1, len(list_)):
        p.next = ListNode(list_[i])
        p = p.next

    return head


def print_link_list(head: Optional[ListNode]) -> Optional[ListNode]:
    p = head
    while p:
        print(p.val)
        p = p.next
    return head


def main():
    # Input: head = [1,2,3,4,5]
    # Output: [3,4,5]
    # Explanation: The middle node of the list is node 3.
    solution1 = Solution()
    head = solution1.middleNode(list2link([1, 2, 3, 4, 5]))
    print_link_list(head)

    print('---')

    # Input: head = [1,2,3,4,5,6]
    # Output: [4,5,6]
    # Explanation: Since the list has two middle nodes with values 3 and 4, we return the second one.
    solution2 = Solution()
    head = solution2.middleNode(list2link([1, 2, 3, 4, 5, 6]))
    print_link_list(head)


if __name__ == '__main__':
    main()

26. Remove Duplicates from Sorted Array

https://leetcode.com/problems/remove-duplicates-from-sorted-array/

from typing import List


class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if len(nums) == 0:
            return 0

        slow = 0
        fast = 0
        while fast < len(nums):
            if nums[fast] != nums[slow]:
                slow += 1
                # 保持nums[0-slow]无重复
                nums[slow] = nums[fast]

            fast += 1

        return slow + 1


def main():
    # Input: nums = [1,1,2]
    # Output: 2, nums = [1,2,_]
    solution1=Solution()
    print(solution1.removeDuplicates([1,1,2]))

    print('---')

    # Input: nums = [1,1,2]
    # Output: 2, nums = [1,2,_]
    solution1=Solution()
    print(solution1.removeDuplicates([1,1,2]))


if __name__=='__main__':
    main()

160. Intersection of Two Linked Lists

https://leetcode.com/problems/intersection-of-two-linked-lists/

from typing import Optional


# Definition for singly-linked list.
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        p1 = headA
        p2 = headB
        # NOTE:use is or ==
        while p1 != p2:
            if p1 == None:
                p1 = headB
            else:
                p1 = p1.next

            if p2 == None:
                p2 = headA
            else:
                p2 = p2.next

        return p2


def list2link(list_):
    head = ListNode(list_[0])
    p = head
    for i in range(1, len(list_)):
        p.next = ListNode(list_[i])
        p = p.next

    return head


def print_link_list(head: Optional[ListNode]) -> Optional[ListNode]:
    p = head
    while p:
        print(p.val)
        p = p.next
    return head


def main():
    # intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
    # Output: Intersected at '8'
    # Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect).
    # From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5].
    # There are 2 nodes before the intersected node in A;
    # There are 3 nodes before the intersected node in B.
    solution1 = Solution()
    intersect_head = solution1.getIntersectionNode(list2link([4, 1, 8]), list2link([5, 8]))
    print_link_list(intersect_head)


if __name__ == '__main__':
    main()

27. Remove Element

https://leetcode.com/problems/remove-element/

from typing import List


class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        slow = 0
        fast = 0

        # NOTE:结束条件！！！结束条件需为fast可以取到列表最后一个元素
        while fast <= len(nums) - 1:
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1

        # if slow == 0: return 1, nums[0]
        return slow, nums[0:slow]


def main():
    # Input: nums = [3,2,2,3], val = 3
    # Output: 2, nums = [2,2,_,_]
    solution1 = Solution()
    print(solution1.removeElement([3, 2, 2, 3], 3))

    print('---')

    # Input: nums = [0,1,2,2,3,0,4,2], val = 2
    # Output: 5, nums = [0,1,4,0,3,_,_,_]
    solution2 = Solution()
    print(solution2.removeElement([0, 1, 2, 2, 3, 0, 4, 2], val=2))
    
    print('---')

    # Input: nums = [2], val = 3
    # Output: [2]
    #
    # while fast < len(nums) - 1:
    # (0, []) 错，reason：快指针没有取到最后一个元素len-1
    # while fast < len(nums):
    # (1, [2]) 对
    solution3 = Solution()
    print(solution3.removeElement([2], val=3))


if __name__ == '__main__':
    main()

linkedlist-has-circle

"""
链表成环判定：使用双指针中的快慢指针解决
procedure：
每当慢指针 slow 前进一步，快指针 fast 就前进两步。

如果 fast 最终遇到空指针，说明链表中没有环；
如果 fast 最终和 slow 相遇，那肯定是 fast 超过了 slow 一圈，说明链表中含有环。
"""
from typing import Optional


class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next


# 链表成环判定：快慢指针技巧，含环返回True，不含返回False
def linkedlist_hasCircle(head: Optional[ListNode]) -> bool:
    fast = head
    slow = head
    # 终止条件：快指针走到末尾时停止
    while fast and fast.next:
        # 过程：快走两步，慢走一步，若此过程中二者相遇则说明链表含环
        slow = slow.next
        fast = fast.next.next
        if fast == slow:
            return True

    return False


# 含环链表返回环起点
def linkedlist_circle_point(head: Optional[ListNode]) -> Optional[ListNode]:
    fast = head
    slow = head
    # 成环判定：快两步，慢一步，二者相等时即含环
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        # 【相遇点】快慢指针相遇=>含环=>在快慢指针相遇点终止循环
        if slow == fast: break

    if fast == None or fast.next == None:
        # fast与空指针说明无环
        return None

    # 【环起点】使慢指针重新指向链表头，二者同步前进，再次相交点就是环起点
    slow = head
    while slow != fast:
        slow = slow.next
        fast = fast.next

    return slow
killingwill
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
linux内存管理--进程在内存中的分布
鱼思故渊的专栏
09-26 8099
一、进程与内存     所有进程（执行的程序）都必须占用一定数量的内存，它或是用来存放从磁盘载入的程序代码，或是存放取自用户输入的数据等等。不过进程对这些内存的管理方式因内存用途不一而不尽相同，有些内存是事先静态分配和统一回收的，而有些却是按需要动态分配和回收的。对任何一个普通进程来讲，它都会涉及到5种不同的数据段； 代码段：代码段是用来存放可执行文件的操作指令，也就是说是它是可执行程
break algorithm---暴力搜索：回溯（1）
qq_41875506的博客
04-24 1879
😡😡😡 声明： 算法基于https://labuladong.github.io/ python语言实现 core mind 46.permutations 51.n-queens 77.combinations 78.subsets 90.subsets-ii 698.partition-to-k-equal-sum-subsets 😡😡😡 core mind 【回溯算法秒杀所有排列/组合/子集问题】https://labuladong.github.io/algo/4/29/107/.
Latex 算法跨页（algorithm，breakablealgorithm）
houxiaogang05
02-21 6291
出处： https://tex.stackexchange.com/questions/33866/algorithm-tag-and-page-break Latex算法跨页显示例子： \documentclass{article} \usepackage{algorithm,algpseudocode,float} \usepackage{lipsum} \makeatletter \ne...
排序算法粗略总结
02-10 549
以整数数组递增排序为例： 1. 选择排序 selection sort 从第一个元素开始，在全数组里寻找最小的数，和第一个元素交换； 前进至第二个元素，在第二个元素为起始的余下数组中寻找最小的数，和第二个元素交换； 可以递归实现： SelectionSortRecursion( data, start ) {     if( start     {         swap
快慢指针 find linkedlist 中间元素
cncnlg的专栏
11-15 595
void findMid(node *s) { node *p,*q; q=s->next; p=s->next; while(q) { if(q->next==NULL)//奇数个元素 { coutdata; return ;} else if(q
pentaho-aggdesigner-algorithm-5.1.5-jhyde.tar
06-09
mvn install:install-file -DgroupId=org.pentaho -DartifactId=pentaho-aggdesigner-algorithm -Dversion=5.1.5-jhyde -Dpackaging=jar -Dfile=D:/pentaho-aggdesigner-algorithm-5.1.5-jhyde.jar
pentaho-aggdesigner-algorithm-5.1.5-jhyde.jar.zip
01-05
解决maven引入hive的jar包时依赖报错Could not find artifact org.pentaho:pentaho-aggdesigner-algorithm:pom:5.1.5-jhyde in xxx的问题，maven路径org/pentaho/pentaho-...aggdesigner-algorithm-5.1.5-jhyde.jar
pentaho-aggdesigner-algorithm-5.1.5-jhyde.zip
02-23
org / pentaho / pentaho-aggdesigner-algorithm / 5.1.5-jhyde / pentaho-aggdesigner-algorithm-5.1.5-jhyde.jar，解决maven引入hive的jar包时依赖报错Could not find artifact org.pentaho:pentaho-aggdesigner-...
pentaho-aggdesigner-algorithm-5.1.5-jhyde-API文档-中文版.zip
04-23
赠送jar包：pentaho-aggdesigner-algorithm-5.1.5-jhyde.jar； 赠送原API文档：pentaho-aggdesigner-algorithm-5.1.5-jhyde-javadoc.jar； 赠送源代码：pentaho-aggdesigner-algorithm-5.1.5-jhyde-sources.jar； ...
pentaho-aggdesigner-algorithm-5.1.5-jhyde.jar
06-06
Pentaho AggDesigner Algorithm是 Pentaho Data Integration (PDI) 中的一个重要组件，主要用于数据仓库的设计和优化。这个组件的版本是5.1.5-jhyde，它是一个Java编写的库，所以“java”标签恰如其分地指出了它的...
C语言中return、break用法和区别
轻松学C语言
05-20 4409
1returnreturn：跳出当前正在执行函数。使用方法：return （表达式）;其中，（表达式）是可以省略的。1.有返回类型return通常都是带有返回类型的，比如返回int型变量...
Linked List - 单链表找中点 - 快慢指针
DO IT. LOVE IT.
08-01 1393
快慢指针
linked list快慢指针找中点3种写法的不同
星璇的博客
02-22 522
Linked List 用快慢指针找中点的3种写法的不同 fast = head, while (fast.next != null && fast.next.next != null) Node fast = head; while (fast.next != null && fast.next.next != null) { slow = slow.nex...
break使用不当引发的一个“血案”
C语言学习答疑
02-17 237
我是C语言编程答疑者，喜欢用通俗形象的讲解来剖析C语言编程中的抽象点与难点，欢迎关注我，方便你在学习C语言过程中遇到疑难杂症时与我交流_！小伙伴们对本回答有疑点或者兴趣点可以留言讨论哦！要复制粘贴本文文字者务必查看个人简介中有关版权说明！ 最近在网上冲浪，读到一个新闻，说上世纪90年代一天，AT&T电话网络的一交换机挂了，导致数万人长时间不能打长途...
正确规避野指针姿势
break;的博客
10-24 505
（如有错误，请联系我更正，以免误导他人！） 新手必看，大神绕道勿喷。谢谢！ break在前几天写代码时，代码在windows上完美运行，但是放到android上运行时发现有内存泄漏，导致闪退。这个错误源于break写代码时不小心使用了野指针。于是写下这篇文章加深印象，以防以后再犯。   看下面一段代码： class A { public: void Ddd() { cout <<
代码随想录算法训练营第33天
m0_62262158的博客
07-10 156
【代码】代码随想录算法训练营第33天。
牛客小白月赛98 （个人题解）（补全）
最新发布
Wzh20060111的博客
07-13 266
前言：昨天晚上自己一个人打的小白月赛（因为准备数学期末已经写烦了），题目难度感觉越来越简单了（不在像以前一样根本写不了一点，现在看题解已经能看懂一点了），能感受到自己在不断进步，希望在暑假能更努力一点吧，，少打点游戏，多学学算法，还有web的学习也要抓起来了，这几天不是在看高数就是在打游戏，感觉好堕落。
代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树
wonderlandlja的博客
07-11 159
【代码】代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树。
【代码随想录算法训练营第六十二天|卡码网53.寻宝（prim算法和kruskal算法）】
weixin_46281930的博客
07-09 473
kruskal算法以边为导向，先把边按照长度从小到大排序，然后一个个检查边的两个端点是否在同一个集合中（这里使用并查集判断），在同一个集合中就不加入这个边，不在的话就加入。可以把所有已经使用过的结点看作一个整体，然后把他们相接的结点的结点顶点边中进行选择，选择最短的一条边把该结点入树，某种程度来说也是一种贪心？1.选择当前最短入树结点；3.更新结点距离最小生成树的距离。
org.pentaho:pentaho-aggdesigner-algorithm:jar:5.1.5-jhyd
08-06
org.pentaho:pentaho-aggdesigner-algorithm:jar:5.1.5-jhyd是Pentaho聚合设计算法的一个jar包。Pentaho是一种开源的商业智能(BI)和数据集成软件套件，用于帮助用户进行数据分析、报告生成和数据挖掘。 这个jar包包...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

killingwill

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

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

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

打赏作者

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

抵扣说明：

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

余额充值