最最最基础题应知应会题目_1_排序_下载图片

最最最基础题应知应会题目_1_排序_下载图片

 

1、一组数，挑出第二大的数字

　

import re

import requests


def t1(l_, x):
    n = set(l_)
    r = sorted(n, reverse=True)
    return r[x]
print(t1([1, 4, 7, 902, 902], 1), )

　　

快排

def quick_sort(li, start, end):
    # 分治 一分为二
    # start=end ,证明要处理的数据只有一个
    # start>end ,证明右边没有数据
    if start >= end:
        return
    # 定义两个游标，分别指向0和末尾位置
    left = start
    right = end
    # 把0位置的数据，认为是中间值
    mid = li[left]
    while left < right:
        # 让右边游标往左移动，目的是找到小于mid的值，放到left游标位置
        while left < right and li[right] >= mid:
            right -= 1
        li[left] = li[right]
        # 让左边游标往右移动，目的是找到大于mid的值，放到right游标位置
        while left < right and li[left] < mid:
            left += 1
        li[right] = li[left]
    # while结束后，把mid放到中间位置，left=right
    li[left] = mid
    # 递归处理左边的数据
    quick_sort(li, start, left - 1)
    # 递归处理右边的数据
    quick_sort(li, left + 1, end)


if __name__ == '__main__':
    l = [6, 5, 4, 3, 2, 1]
    # l = 3 [2,1,5,6,5,4]
    # [2, 1, 5, 6, 5, 4]
    quick_sort(l, 0, len(l) - 1)
    print(l)
    # 稳定性：不稳定
    # 最优时间复杂度：O(nlogn)
    # 最差时间复杂度：O(n**2)

　　简化编写，效率低，空间复杂度高

　　分治思想

def quick_sort(array):
    if len(array) < 2:
        return array
    else:
        pivot = array[0]
        less_than_pivot = [x for x in array[1:] if x <= pivot]
        more_than_pivot = [x for x in array[1:] if x > pivot]
        return quick_sort(less_than_pivot) + [pivot] + quick_sort(more_than_pivot)

　　注意 分left和right时候 array[1:]  一定排除第一个，如果不排除就会一直循环递归。

 

函数式编程

def quick_sort(L):
    return q_sort(L, 0, len(L) - 1)

def q_sort(L, left, right):
    if left < right:
        pivot = Partition(L, left, right)

        q_sort(L, left, pivot - 1)
        q_sort(L, pivot + 1, right)
    return L

def Partition(L, left, right):
    pivotkey = L[left]
　　# 对指针的控制，所以占用空间少
    while left < right:
        while left < right and L[right] >= pivotkey:   # 右边比L[left]小的第一个复制给L[left]
            right -= 1
        L[left] = L[right]
        while left < right and L[left] <= pivotkey:　　# ？？ 再把原始的L[left]插回去
            left += 1
        L[right] = L[left]　　　　　　　　　　　　　　　　　#   为什么这里是这样？？？？？？
    L[left] = pivotkey        　　　　　　　　　　　　　　　#    应该在循环中赋值？？？？？？？？
    return left

L = [5, 9, 1, 11, 6, 7, 2, 4]

print quick_sort(L)

　　

def qw(al):
    return qs(al, 0, len(al)-1)

def qs(al,lf,rt):
    """if lf<rt:

        v = pv(al,lf,rt)
        qs(al,lf,v-1)
        qs(al,v+1,rt)
    return al"""

    # 这种写法为什么返回为None
    if lf>=rt:
        return al
    else:
        v = pv(al,lf,rt)
        qs(al,lf,v-1)
        qs(al,v+1,rt)
    
    

def pv(al,lf,rt):

    sv = al[lf]
    while lf<rt:
        while lf<rt and al[rt]>=sv:
            rt-=1
        al[lf]=al[rt]
        while lf<rt and al[lf]<=sv:
            lf+=1
        al[rt]=al[lf]
    al[lf]=sv
    return lf

L = [5, 9, 1, 6, 7, 2]
print(qw(L))

　　3.10 理解一个中间值左右分开lf和rt，然后rt先与其附近比较再次做小范围排序，尽最大可能中间值的左右两边是大于小于这个值。

　　　　先听讲解

　　　　

　　　　伪代码：

　　　　　　1 获取一个中间点

　　　　　　2 处理中间点左边部分

　　　　　　3 处理中间点右边部分

　　　　　　4 每个部分怎么处理

　　　　步骤4 的基本操作为，起始点left值保存在 priv中，right>priv,直到右侧有小于priv，右侧值挪到左边即右侧值赋值左侧，

　　　　　　　　　　　　　　　　　　　　　　　　　　left<priv，直到左侧有大于priv，左侧值挪到右边right即左侧值赋值右侧。

　　　　　　　　　　　　　　　　　　　　　　　　　　这时left所处值有两个，一个是本身一个是right

　　　　　　　　　　　　　　　　　　　　　　　　　　用事先存储的分割点值priv赋值给left，这样就完成双指针替换，不占用更多内存

　　　　　　　　　　　　　　　　　　　　　　　　　　返回left索引

　　　　1分治思想，2 先写伪代码 3 双指针操作必须熟练

　　　　　　　　3的示意图

 

 

2、数据量很多采用什么方法？

  采用什么数据结构

　　

3、下载一组图片

输入一个元素为字符串的列表

def get_url(u, m="POST"):
    for u_ in u:
        r = requests.request(m, u_)
        html = r.content
        print(html)
        with open('%s.png' % u_.split("/")[-1].split(".")[0], 'wb') as f:
            f.write(html)
        return
u1="https://up.ruyile.com/jy_img/cj/14/169/33520l91.jpg"
# u2="https://img.tupianzj.com/uploads/allimg/202007/9999/5f552d9fd7.jpg"
tu = [u1]
print(get_url(tu))

　　下载的图片有问题

image not loaded  try to open it externally to fix format problem

 

4、采用什么方法测试

 

5、代码有哪些优化空间

　　1 保护

　　2 中断怎么办

　　3 特别大的连接怎么办

　　4 数量巨大怎么办