刷题中的二分查找，双指针总结(持续跟新)

我自己做的话，边界条件不太熟悉

双指针

剑指反转链表
**剑指两链表的第一个公共节点

剑指链表环的入口节点（快慢指针）**

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

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        if not head or not head.next:
            return False
        s=head
        f=head.next
        while s != f:
            if not f or not f.next:
                return False
            s=s.next
            f=f.next.next
        return True

leetcode202-快乐数（快慢指针）

得出不为快乐数，快慢指针总会相遇很重要

class Solution:
    def isHappy(self, n: int) -> bool:
        # 快慢指针，慢指针前进一个节点，快指针前进二个节点
        #if n=快乐数（无循环），快最终比慢先到达1
        #else n不为快乐数（循环），在循环里，他们最终会相遇（为了防止无限循环，需要打断）
        时间复杂度o(logn)，空间复杂度o(1)
        分析：无循环，进行一次happy为logn，有循环也是（不清楚看一下题解）
        def happy(number):
            total_sum=0
            while number > 0:
                number,digit=divmod(number,10)
                total_sum+=digit**2
            return total_sum
        s=n
        f=happy(n)
        while f!=s and f!=1: 
            s=happy(s)
            f=happy(happy(f))
        return f==1

        

剑指offer58-翻转句子中单词出现的顺序

class Solution:
    def reverseWords(self, s: str) -> str:
        s = s.strip() # 删除首尾空格
        i = j = len(s) - 1
        res = []
        while i >= 0:
            while i >= 0 and s[i] != ' ': i -= 1 # 搜索首个空格
            res.append(s[i + 1: j + 1]) # 添加单词
            while s[i] == ' ': i -= 1 # 跳过单词间空格
            j = i # j 指向下个单词的尾字符
        return ' '.join(res) # 拼接并返回

二分查找

剑指offer53-Ⅱ 0~n-1中缺失的数

class Solution:

时间复杂度o(logn)

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        i, j = 0, len(nums) - 1
        while i <= j:
            m = (i + j) // 2
            if nums[m] == m: i = m + 1
            else: j = m - 1
        return i

作者：jyd
链接：https://leetcode-cn.com/problems/que-shi-de-shu-zi-lcof/solution/mian-shi-ti-53-ii-0n-1zhong-que-shi-de-shu-zi-er-f/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。`

剑指offerJA37-统计一个数字在排序数组中出现次数

# -*- coding:utf-8 -*-
class Solution:
    def GetNumberOfK(self, data, k):
        if not data or data[0] > k or data[-1] < k:
            return 0
        low = 0
        high = len(data) - 1
        cnt = 0
        while low <= high:
            medium = (low + high) / 2
            if data[medium] == k:
                while medium >= 0 and data[medium] == k:
                    medium -= 1
                medium += 1
                while medium <= high and data[medium] == k:
                    medium += 1
                    cnt += 1
                return cnt
            elif data[medium] < k:
                low = medium + 1
            else:
                high = medium - 1
        return cnt

JZ6 旋转数组的最小数字

注意：
right = mid# 如果是-1会错误
right -= 1# 出现这种情况的array类似 [1,0,1,1,1] 或者[1,1,1,0,1]，此时最小数字不好判断在mid左边右边，只好一个一个试
return rotateArray[left]# 如果待查询的范围最后只剩两个数，那么mid 一定会指向下标靠前的数

# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        if not rotateArray:
            return 0
        left = 0
        right = len(rotateArray) - 1
        while left <= right:
            mid = (left + right) / 2
            if rotateArray[mid] > rotateArray[right]:# 中间元素位于前面的递增子数组
                left = mid + 1
            elif rotateArray[mid] < rotateArray[right]:# 中间元素位于后面的递增子数组
                right = mid# 如果是-1会错误
            else:
                right -= 1# 出现这种情况的array类似 [1,0,1,1,1] 或者[1,1,1,0,1]
                #此时最小数字不好判断在mid左边右边，只好一个一个试

            if left >= right:
                break
        return rotateArray[left]# 如果待查询的范围最后只剩两个数，那么mid 一定会指向下标靠前的数字

剑指JZ29 和为S的两个数字

好好看看双指针的思路

# -*- coding:utf-8 -*-
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        if not array:
            return []
        left = 0 
        right = len(array) - 1
        while left < right:
            if array[left] + array[right] > tsum:
                right -= 1
            elif array[left] + array[right] < tsum:
                left += 1
            else:
                return [array[left],array[right]]# 两数离得越远乘积越小
        return []