数据结构和算法

标签：插入排序   遍历   占用   change   app   内存   一个   数据结构和算法   选择排序   

数据结构和算法

什么是数据结构和算法：

? 数据结构定义：我们如何把现实中的问题以特定的存储结构和存储类型保存起来

时间复杂度：用来评估算法运行时间的一个式子（单位）

一般来说，时间 复杂度高的算法比复杂度低的算法慢。

常见的时间复杂度（按效率排序)

O(1)<O(log n)<O(n)<O(nlog n)<O(n^2)<O(n^2log n)<O(n^3)

如何一眼判断时间复杂度？

循环减半的过程------->O(log n)
几次循环就是n的几次方的复杂度

空间复杂度：用来评估算法内存占用 大小 的一个式子

装饰器：

def cal_time(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()
        print('%s执行的时间是%s' % (func.__name__, end - start))
        return res
    return wrapper

冒泡排序：

@cal_time
def bubble_sort(li)：
    for i in range(len(li)-1):
        for j in range(len(li)-i-1):
            if li[j]>li[j+1]:
                li[j],li[j+1]=li[j+1],li[j]
 li=[5,3,1,2,4,8,9,7,6]               
 bubble_sort()   
 时间复杂度：O(n^2)

冒泡排序优化：

@cal_time
def bubble_sort(li)：
    for i in range(len(li)-1):
        exchange=False
        for j in range(len(li)-i-1):
            if li[j]>li[j+1]:
                li[j],li[j+1]=li[j+1],li[j]
                exchange = True
        if  not exchange:
            return
 li=[5,3,1,2,4,8,9,7,6]               
 bubble_sort()   

选择排序

思路：

一趟遍历记录最小的数，放到第一个位置；
再一趟遍历记录剩余列表中最小的数，继续放置；
......
问题是：怎么选择出最小的数？
代码关键点：
无序区
最小数的位置

代码：

@cal_time
def select_sort(li):
    for i in range(len(li)-1):
        min_loc=i
        for j in range(i+1,len(li)):
            if li[j]<li[min_loc]:
                min_loc=j:
        if min_loc !=i:
            li[i],li[min_loc] = li[min_loc],li[i]
时间复杂度：O(n^2)            

插入排序

插入排序代码：

def insert_sort(li):
    for i  in range(1,len(li)):
        tmp =  li [i]
        j =j-1
        while j >= 0 and tmp <li[j]:
            li[j+1]=li[j]
            j=j-1
        li[j+1]=tmp
时间复杂度：O(n^2)        

归并排序

# 时间复杂度: O(nlogn)
# 空间复杂度: O(n)
def merge(li, left, mid, right):
    i = left
    j = mid + 1
    itmp = []
    while i <= mid and j <= right:
        if li[i] < li[j]:
            itmp.append(li[i])
            i = i + 1
        else:
            itmp.append(li[j])
            j = j + 1
    while i <= mid:
        itmp.append(li[i])
        i = i + 1
    while j <= right:
        itmp.append(li[j])
        j = j + 1
    li[left:right + 1] = itmp


def merge_sort(li, left, right):
    if left < right:
        mid = (left + right) // 2
        merge_sort(li, left, mid)
        merge_sort(li, mid + 1, right)
        print('归并之前:', li[left:right + 1])
        merge(li, left, mid, right)
        print('归并之后：', li[left:right + 1])

快速排序：

代码：

# 快速排序
# 时间复杂度：n log
# 空间复杂度：O(1)
def patition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and tmp <= li[right]:
            right = right - 1
        li[left] = li[right]
        while left < right and tmp >= li[left]:
            left = left + 1
        li[right] = li[left]
    li[left] = tmp
    return left


def quick_sort(li, left, right):
    if left < right:
        mid = patition(li, left, right)
        quick_sort(li, left, mid - 1)
        quick_sort(li, mid + 1, right)

@cal_time
def quick(li, left, right):
    quick_sort(li, left, right)
    
quick(li, 0, len(li) - 1)

数据结构和算法

标签：插入排序   遍历   占用   change   app   内存   一个   数据结构和算法   选择排序   

原文地址：https://www.cnblogs.com/xuecaichang/p/10327630.html