快速了解算法和四大排序

算法

算法是一种针对某个问题完整有效的，具备完整清晰指令的策略。

同样一个问题，可以由多种算法实现，我们需要做的是尽量最优。

算法在评价的时候具有时间复杂度，空间复杂度。

时间复杂度：执行消耗时间。采用大O记法。

空间复杂度：消耗的资源。

时间复杂度与空间复杂度成反比。

当时间复杂度低时必定会消耗大量的资源，即空间复杂度高。当空间复杂度低时必定会消耗大量的时间，即时间复杂度高。

在考虑算法的优劣的时候，我们通常采用最悲观态度。

比如说，上班的时候老板找小王，他一进办公室就叫小王的名字，此时立马就可以找到小王，这就是最优方案。

另一种情况就是老板找小王在办公室里挨着找，直到找到小王为止，这就是最悲观态度。

排序

冒泡排序

冒泡排序就是在一组数据中，相邻元素依次比较大小，最大的放后面，最小的冒上来

lst=[5, 2, 0, 4, 7, 3, 8, 1, 6, 9]
lenth=len(lst)
for i in range(lenth):
    inner_lenth=lenth-i
    for j in range(inner_lenth):
        first=lst[j]
        next=lst[j+1]
        if first>next:
            lst[j],lst[j+1]=lst[j+1],lst[j]
print(lst)

选择排序

（1）选择最小值

（2）遍历其他的值，若小于最小值便和他换位置

lst=[1, 7, 2, 9, 4, 8, 6, 3, 5, 0]
lenth=len(lst)
for i in range(lenth):
    for j in range(i+1,lenth):
        outer_num=lst[i]
        inner_num=lst[j]
        if outer_num>inner_num:
            lst[i],lst[j]=lst[j],lst[i]
print(lst)

 插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。

lst=[6, 7, 3, 1, 0, 8, 2, 5, 9, 4]
lenth=len(lst)
for i in range(lenth):
    while i >0 and lst[i-1]>lst[i]:
        lst[i-1],lst[i]=lst[i],lst[i-1]
        i-=1
    print(lst)

快速排序

快速排序是一种分治排序算法。先把数组重新整理分割两个子数组，然后对两个子数组进行排序。

lst=[1, 7, 2, 9, 4, 8, 6, 3, 5, 0]
def quick_sork(lst,start,end):
    if start>=end:
        return
    mid=lst[start]
    low=start
    high=end
    while low<high:
        while low<high and lst[high]>=mid:
            high-=1
        lst[low]=lst[high]
        while low<high and lst[low]<mid:
            low+=1
        lst[high]=lst[low]
    lst[low]=mid
    quick_sork(lst,start,low-1)
    quick_sork(lst,low+1,end)
quick_sork(lst,0,len(lst)-1)
print(lst)

各大排序的时、空复杂度