python3 快速排序 双指针相遇的十种情况

#双指针 快速排序 O(nlogn)
def quickSort(listA,start,end):
    if(listA == None or len(listA) == 0):
        return -1

    #递归出口:
    if(start >= end):
        return -1

    left = start
    right = end
    pivotValue = listA[(start+end)//2]

    while(left<=right):
        #listA[left]<pivotValue
        # not listA[left]<=pivotValue
        #保证最后双指针相遇的地方
        #左右两边元素个数大致相等
        #logn
        while(left<=right and listA[left]<pivotValue):
            #listA[left]<pivotValue
            #left停到大于等于 pivotValue处,再交换,移动
            #left<=right
            #此内层循环left最多停到right+1处
            left+=1
        while(left<=right and listA[right]>pivotValue):
            #listA[right]>pivotValue
            #right停到小于等于pivotValue处,再交换移动
            #left<=right
            #此内层循环right最多停到left-1处
            right-=1

        #left<=right 交换,向右移动left,向左移动right
        #没有等于,则会导致递归无限死循环
        #(手动尝试两个不一样数字,体验递归死循环,找不到递归出口)
        #所以:left right 相等时,必须更新

        #准确来说,两个指针的相遇有九种情况+1:
        #  left  right
        #   <      <
        #   <      =
        #   <      >
        #  left  right
        #   =      <
        #   =      =
        #   =      >
        #  left  right
        #   >      <
        #   >      =
        #   >      >
        #还有指向同一元素情况(在交换移动后指向同一个元素)
        
        #解决复杂排序问题:
        #1. 列出各种情况
        #2. 分情况讨论
        #3. 将各种情况归纳总结

        #另一种标准分类:(宏观上把握)
        # left<=right 可以保证left right 差值 <=1
             #  ^     ^   #
             # left right #
        # <= #  >=   <=   # >=

             #      ^      #
             #  left right #
        # <= #     =  =    # >=

            #  ^     ^   #
            # right left #
        # <= #  <=   >=   # >=
        
        #交换完成最终:
        #1. right = left + 1 
        #2. right = left + 2(中间元素=pivotValue)
        if(left<=right):
            listA[left],listA[right] = listA[right],listA[left]
            left+=1
            right-=1
    

    #right右边全部比 pivotValue 大,且right指向<=
    quickSort(listA,start,right)
    #left 左边全部比 pivotValue小,且left指向>=
    quickSort(listA,left,end)

list1 = [5,7,3,6,5,4,9,8,0,2,1]
quickSort(list1,0,10)
print(list1)
[0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9]
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
快速排序可以使用双指针法来实现。双指针法是通过两个指针i和j分别从数组的两端开始搜索,直到找到需要交换的元素。当i和j相遇时,表示搜索结束。 具体实现步骤如下: 1. 选择一个基准元素,可以是数组的第一个元素或者随机选取一个元素作为基准元素。 2. 初始化两个指针i和j,分别指向数组的起始位置和末尾位置。 3. 从右向左移动指针j,直到找到一个小于等于基准元素的元素。 4. 从左向右移动指针i,直到找到一个大于等于基准元素的元素。 5. 如果i小于等于j,则交换指针i和指针j所指向的元素。 6. 继续执行步骤3到步骤5,直到i大于j。 7. 将基准元素与指针j所指向的元素交换位置,此时基准元素的位置已经确定。 8. 对基准元素左边的子数组和右边的子数组分别进行递归排序,直到子数组的长度为1或者0。 下面是一个使用双指针法实现快速排序的示例代码: ```python def quick_sort(arr, low, high): if low < high: pivot_index = partition(arr, low, high) quick_sort(arr, low, pivot_index - 1) quick_sort(arr, pivot_index + 1, high) def partition(arr, low, high): pivot = arr[low] i = low + 1 j = high while True: while i <= j and arr[i] < pivot: i += 1 while i <= j and arr[j] > pivot: j -= 1 if i <= j: arr[i], arr[j] = arr[j], arr[i] else: break arr[low], arr[j] = arr[j], arr[low] return j # 示例用法 arr = [5, 2, 8, 9, 1, 3] quick_sort(arr, 0, len(arr) - 1) print(arr) # 输出:[1, 2, 3, 5, 8, 9] ```

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值