码迷,mamicode.com
首页 > 编程语言 > 详细

算法基础

时间:2020-04-02 18:16:04      阅读:76      评论:0      收藏:0      [点我收藏+]

标签:一个   图片   png   partition   lang   就是   header   运行时间   循环   

算法

时间复杂度

算法的时间复杂度是一个函数,它定量描述了该算法的运行时间,时间复杂度常用“O”表述,使用这种方式时,时间复杂度可被称为是渐近的,它考察当输入值大小趋近无穷时的情况

技术图片

技术图片

时间复杂度小结:

时间复杂度是用来估计算法运行时间的一个式子(单位)

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

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

O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n2logn)<O(n3)

不常见的时间复杂度(看看就好)

O(n!) O(2n) O(nn) …

如何一眼判断时间复杂度

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


空间复杂度

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

“空间换时间”


冒泡排序

思路:首先,列表每两个相邻的数,如果前边的比后边的大,那么交换这两个数

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]

时间复杂度:O(n2)

冒泡排序优化

如果冒泡排序中执行一趟而没有交换,则列表已经是有序状态,可以直接结束算法

def bubble_sort(li):
    for i in range(len(li)-1):
        flag = True
        for j in range(len(li)-1-i):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
                flag = False
        if flag:
            return

选择排序

思路:一趟遍历记录最小的数,放到第一个位置;
再一趟遍历记录剩余列表中最小的数,继续放置;

def select_sort(li):
    for i in range(len(li)):
        minLoc = i
        for j in range(i+1, len(li)):
            if li[minLoc] > li[j]:
                li[minLoc], li[j] = li[j], li[minLoc]

时间复杂度:O(n2)


插入排序

列表被分为有序区和无序区两个部分。最初有序区只有一个元素。
每次从无序区选择一个元素,插入到有序区的位置,直到无序区变空

li = [5, 7, 4, 6, 3, 1, 2, 9, 8]
def insert_sort(li):
    for i in range(1, len(li)):  ### i=2
        tmp = li[i] ## tmp=li[2]=4
        j = i - 1  ### j = 1 li[1]=7

        while j >= 0 and li[j] > tmp:
            li[j+1] = li[j]  ### [5,7,7,6,3,8,2,9,1]  ==> [5,5,7,6,3,8,2,9,1]
            j = j - 1   ### j = 0  j= -1

        li[j+1] = tmp

时间复杂度:O(n2)

快速排序

快排思路:
取一个元素p(第一个元素),使元素p归位;
列表被 p 分成两部分,左边都比 p 小,右边都比 p 大;
递归完成排序。

技术图片

##### 时间复杂度是:O(nlogn)
def partition(li, left, right):  #### O(n)

    tmp = li[left]  # 把最左边的存到一个变量里

    while left < right:
        while left < right and li[right] >= tmp:  # 如果最右边的比最左边的大
            right = right - 1  # right 指针向左移 1,再继续下次比较,结果还是大,继续往左移1,如果比left小,跳出循环,移到最左边
        li[left] = li[right]

        while left < right and li[left] <= tmp:
            left = left + 1
        li[right] = li[left]

    li[left] = tmp  # 此时left和right重合到了一起,就可以让最开始的那个变量归位了

    return left

def quick_sort(li, left, right):

    if left < right:
        mid = partition(li, left, right)  ### 归位函数

        # 递归
        quick_sort(li, left, mid-1)     #### O(logn)
        quick_sort(li, mid+1, right)

时间复杂度是:O(nlogn)


算法基础

标签:一个   图片   png   partition   lang   就是   header   运行时间   循环   

原文地址:https://www.cnblogs.com/kai-/p/12621045.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!