1、什么是算法

2、递归

  1. # 一直递归，递归完成再打印
  2. def func4(x):
  3.     if x > 0:
  4.         func4(x - 1)
  5.         print(x)
  6.  
  7. func4(5)

3、时间 复杂度

（1）引入

  1. 时间复杂度：用来评估算法运行效率的一个东西

              

   

（2）小结

  1. 时间复杂度是用来估计算法运行时间的一个式子（单位）。
  2. 一般来说，时间复杂度高的算法比复杂度低的算法快

　　

（3）判断标准

     

（4）空间复杂度

4、列表查找：二分查找

（1）线性查找（顺序查找）

（2）二分查找

（3）alex版本

  1. 重新开辟了一块字典空间

　　

（5）对比

  1. 不要在一个递归函数上直接加装饰器

　　

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # @Time    : 2018/07/30 0030 9:54
  4. # @Author  : Venicid
  5. # @Site    :
  6. # @File    : 02_half_search.py
  7. # @Software: PyCharm
  8.  
  9. import time
  10.  
  11. def cal_time(func):
  12.     def wrapper(*args, **kwargs):
  13.         t1 = time.time()
  14.         x = func(*args, **kwargs)
  15.         t2 = time.time()
  16.         print("Time cost: ",func.__name__, t2-t1)
  17.         return x
  18.     return wrapper
  19.  
  20. # 线性查找
  21. @cal_time
  22. def linear_search(data_set,value):
  23.     for i in range(len(data_set)):
  24.         if data_set[i] == value:
  25.             return i
  26.     return 0
  27.  
  28. # alex版本的
  29. # 不要在一个递归函数上直接加装饰器
  30. # @cal_time
  31. def _binary_search(dataset, find_num):
  32.     if len(dataset) > 1:
  33.         mid = int(len(dataset) / 2)
  34.         if dataset[mid] == find_num:  # find it
  35.             pass
  36.             # print("找到数字", dataset[mid])
  37.         elif dataset[mid] > find_num:  # 找的数在mid左面
  38.             # print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
  39.             return _binary_search(dataset[0:mid], find_num)
  40.         else:  # 找的数在mid右面
  41.             # print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
  42.             return _binary_search(dataset[mid + 1:], find_num)
  43.     else:
  44.         if dataset[0] == find_num:  # find it
  45.             pass
  46.             # print("找到数字啦", dataset[0])
  47.         else:
  48.             pass
  49.             # print("没的分了,要找的数字[%s]不在列表里" % find_num)
  50.  
  51. @cal_time
  52. def binary_search(data_set, val):
  53.     return _binary_search(data_set, val)
  54.  
  55. # 二分法必须是有序列表
  56. @cal_time
  57. def half_search(data_set, value):
  58.     low = 0
  59.     high = len(data_set) - 1
  60.  
  61.     while low <= high:
  62.         mid = (low + high) // 2
  63.         if data_set[mid] == value:
  64.             return mid
  65.         elif data_set[mid] > value:
  66.             high = mid - 1
  67.         else:
  68.             low = mid + 1
  69.  
  70. data = list(range(100000000))
  71. linear_search(data, 153)
  72. binary_search(data, 153)
  73. half_search(data, 153)

（6）列表查找：练习

  1. [
  2. {id:1001, name:"张三", age:20},
  3. {id:1002, name:"李四", age:25},
  4. {id:1004, name:"王五", age:23},
  5. {id:1007, name:"赵六", age:33}
  6. ]

  1. # -*- coding: utf-8 -*-
  2. # @Time    : 2018/07/30 0030 11:42
  3. # @Author  : Venicid
  4. import random
  5. def random_list(n):
  6.     """生成学生信息表"""
  7.     ret = []
  8.     ids = list(range(100,100+n))
  9.     name_1 = ['赵','钱','孙','李','王']
  10.     name_2 = ['打','算','发','的','撒','个','法','师']
  11.     name_3 = ['梅','兰','竹','菊','天','下','第','一']
  12.     for i in range(n):
  13.         dic = {}
  14.         dic['id'] = ids[i]
  15.         dic['name'] = random.choice(name_1)+random.choice(name_2)+random.choice(name_3)
  16.         dic['age'] = random.randint(18, 55)
  17.         ret.append(dic)
  18.     return ret
  19.  
  20. def half_search(data_set, value):
  21.     low = 0
  22.     high = len(data_set) - 1
  23.  
  24.     while low <= high:
  25.         mid = (low+high) //2
  26.         if data_set[mid]['id'] == value:
  27.             return mid
  28.         elif data_set[mid]['id'] > value:
  29.             high = mid-1
  30.         else:
  31.             low = mid+1
  32.  
  33. stus = random_list(5)
  34. ret = half_search(stus,104)
  35. print('index',ret)
  36. print(stus[ret])

5、列表排序

                 

6、冒泡排序

　　（1）冒泡排序思路

       

　　（2）基础版本

　　（3）冒泡排序-优化

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

　　

　（4）最优时间复杂度，最坏时间复杂度

  1. # -*- coding: utf-8 -*-
  2. # @Time    : 2018/07/30 0030 13:06
  3. # @Author  : Venicid
  4.  
  5. import random
  6. import time
  7.  
  8. def cal_time(func):
  9.     def wrapper(*args, **kwargs):
  10.         t1 = time.time()
  11.         x = func(*args, **kwargs)
  12.         t2 = time.time()
  13.         print("Time cost: ",func.__name__, t2-t1)
  14.         return x
  15.     return wrapper
  16.  
  17. # 冒泡排序  O(n)   最坏时间复杂度
  18. @cal_time
  19. def bubble_sort(li):
  20.     for i in range(len(li) - 1):  # 趟数
  21.         for j in range(len(li) - i - 1):     # j表示每次遍历需要比较的次数，是逐渐减小的
  22.             if li[j] > li[j + 1]:  # 从小到大
  23.                 # if li[j] < li[j + 1]:   # 从大到小
  24.                 li[j], li[j + 1] = li[j + 1], li[j]
  25.  
  26. # 冒泡排序  优化
  27. @cal_time
  28. def bubble_sort_1(li):
  29.     for i in range(len(li) - 1):
  30.         exchange = False
  31.         for j in range(len(li) - i - 1):
  32.             if li[j] > li[j + 1]:
  33.                 li[j], li[j + 1] = li[j + 1], li[j]
  34.                 exchange = True
  35.         if not exchange:
  36.             break
  37.  
  38. data = list(range(1000))        # 理想状态的，有序list   最优时间复杂度
  39. # random.shuffle(data)  # 洗牌
  40. bubble_sort(data)
  41. bubble_sort_1(data)
  42. print(data)

7 、选择排序

　　（1）选择排序思路

　　（2）选择排序代码

  1. def select_sort(li):
  2.     for i in range(len(li)-1):
  3.         min_index = i          # 记录最小位置
  4.         for j in range(i+1, len(li)):
  5.             if li[j] < li[min_index]:
  6.                 min_index = j
  7.         if min_index != i:      # 如果选择出的数据不在正确位置，进行交换
  8.             li[i],li[min_index] = li[min_index],li[i]
  9.  
  10. data = list(range(1000))
  11. random.shuffle(data)  # 洗牌
  12. select_sort(data)
  13. print(data)

8、插入排序

　　（1）思路

　　　　

　　　　

　　（2）演示图

  1. def insert_sort(li):
  2.     for i in range(1, len(li)):  # 从第二个位置，即下标为1的元素开始向前插入
  3.         tmp = li[i]
  4.         j = i - 1
  5.         while j >= 0 and li[j] > tmp:
  6.             li[j + 1] = li[j]
  7.             j = j - 1
  8.         li[j + 1] = tmp
  9.  
  10. data = list(range(1000))
  11. random.shuffle(data)  # 洗牌
  12. insert_sort(data)
  13. print(data)

9、总结--排序Lowb 三人组

  1. # -*- coding: utf-8 -*-
  2. # @Time    : 2018/07/30 0030 11:42
  3. # @Author  : Venicid
  4.  
  5. import random
  6. import time
  7.  
  8. def random_list(n):
  9.     """生成学生信息表"""
  10.     ret = []
  11.     ids = list(range(100,100+n))
  12.     name_1 = ['赵','钱','孙','李','王']
  13.     name_2 = ['打','算','发','的','撒','个','法','师']
  14.     name_3 = ['梅','兰','竹','菊','天','下','第','一']
  15.     for i in range(n):
  16.         dic = {}
  17.         dic['id'] = ids[i]
  18.         dic['name'] = random.choice(name_1)+random.choice(name_2)+random.choice(name_3)
  19.         dic['age'] = random.randint(18, 55)
  20.         ret.append(dic)
  21.     return ret
  22.  
  23. def bubble_sort(li):
  24.     for i in range(len(li)-1):
  25.         for j in range(len(li)-i-1):
  26.             if li[j]['id'] > li[j+1]['id']:
  27.                 li[j],li[j+1]=li[j+1],li[j]
  28.  
  29. stus = random_list(5)
  30. random.shuffle(stus)
  31. print(stus)
  32. bubble_sort(stus)
  33. print(stus)

10、快速排序：选出基准元素

（1）思路

　　（2）过程图

　　（3）快速排序代码第一步

         

　　（4）partition函数

  1. def quick_sort(data, left, right):
  2.     if left<right:      # 递归的退出条件
  3.         mid = partition(data, left,right)
  4.         quick_sort(data,left,mid-1)         # 对基准元素左边的子序列进行快速排序
  5.         quick_sort(data,mid+1, right)       # 对基准元素右边的子序列进行快速排序
  6.  
  7. def partition(data,left, right):
  8.     tmp = data[left]
  9.     while left<right:
  10.         while left < right and data[right] >=tmp:   # 如果left与right未重合，right指向的元素不比基准元素小，则right向左移动
  11.             right -=1
  12.         data[left] = data[right]                    # 将right指向的元素放到left的位置上
  13.  
  14.         while left <right and data[left] <= tmp:
  15.             left+=1
  16.         data[right] = data[left]
  17.  
  18.     data[left] = tmp        # 将基准元素放到该位置
  19.     return left
  20.  
  21. data = list(range(1000))
  22. random.shuffle(data)  # 洗牌
  23. quick_sort(data,0,len(data)-1)
  24. print(data)

　　（5）冒泡，快速，sort对比

  1. # -*- coding: utf-8 -*-
  2. # @Time    : 2018/07/30 0030 15:34
  3. # @Author  : Venicid
  4.  
  5. import time
  6. import copy
  7. import sys
  8.  
  9. def cal_time(func):
  10.     def wrapper(*args, **kwargs):
  11.         t1 = time.time()
  12.         x = func(*args, **kwargs)
  13.         t2 = time.time()
  14.         print("Time cost: ", func.__name__, t2 - t1)
  15.         return x
  16.  
  17.     return wrapper
  18.  
  19. # 冒泡排序  优化
  20. @cal_time
  21. def bubble_sort_1(li):
  22.     for i in range(len(li) - 1):
  23.         exchange = False
  24.         for j in range(len(li) - i - 1):
  25.             if li[j] > li[j + 1]:
  26.                 li[j], li[j + 1] = li[j + 1], li[j]
  27.                 exchange = True
  28.         if not exchange:
  29.             break
  30.  
  31. # 快速排序
  32. # 不能直接在递归函数上写装饰器
  33. def quick_sort__(data, left, right):
  34.     if left<right:      # 递归的退出条件
  35.         mid = partition(data, left,right)
  36.         quick_sort__(data,left,mid-1)         # 对基准元素左边的子序列进行快速排序
  37.         quick_sort__(data,mid+1, right)       # 对基准元素右边的子序列进行快速排序
  38.  
  39. def partition(data,left, right):
  40.     tmp = data[left]
  41.     while left<right:
  42.         while left < right and data[right] >=tmp:   # 如果left与right未重合，right指向的元素不比基准元素小，则right向左移动
  43.             right -=1
  44.         data[left] = data[right]            # 将right指向的元素放到left的位置上
  45.  
  46.         while left <right and data[left] <= tmp:
  47.             left+=1
  48.         data[right] = data[left]
  49.  
  50.     data[left] = tmp        # 将基准元素放到该位置
  51.     return left
  52.  
  53. @cal_time
  54. def quick_sort(data):
  55.     return quick_sort__(data, 0, len(data)-1)
  56.  
  57. # python自带的sort  （底层是c语言）
  58. @cal_time
  59. def sys_sort(data):
  60.     return data.sort()
  61.  
  62. # print(sys.getrecursionlimit())       # 查看递归深度
  63. sys.setrecursionlimit(100000)         # 设置递归
  64.  
  65. # data = list(range(10000))
  66. data = list(range(1000,1,-1))       # 最坏情况下
  67. # random.shuffle(data)
  68. data1 = copy.deepcopy(data)
  69. data2 = copy.deepcopy(data)
  70. data3 = copy.deepcopy(data)
  71.  
  72. bubble_sort_1(data1)
  73. quick_sort(data2)
  74. sys_sort(data3)

　　递归问题

　　python的递归深度为999

　　正常情况下

  1. 系统的sort底层是c

　　最坏情况下

   

　　（6）快速排序练习

　　学生表排序

  1. # -*- coding: utf-8 -*-
  2. # @Time    : 2018/07/30 0030 16:07
  3. # @Author  : Venicid
  4. import random
  5. def random_list(n):
  6.     """生成学生信息表"""
  7.     ret = []
  8.     ids = list(range(100,100+n))
  9.     name_1 = ['赵','钱','孙','李','王']
  10.     name_2 = ['打','算','发','的','撒','个','法','师']
  11.     name_3 = ['梅','兰','竹','菊','天','下','第','一']
  12.     for i in range(n):
  13.         dic = {}
  14.         dic['id'] = ids[i]
  15.         dic['name'] = random.choice(name_1)+random.choice(name_2)+random.choice(name_3)
  16.         dic['age'] = random.randint(18, 55)
  17.         ret.append(dic)
  18.     return ret
  19.  
  20. def quick_sort(data, left, right):
  21.     if left<right:      # 递归的退出条件
  22.         mid = partition(data, left,right)
  23.         quick_sort(data,left,mid-1)
  24.         quick_sort(data,mid+1, right)      
  25.  
  26. def partition(data,left, right):
  27.     tmp = data[left]
  28.     while left<right:
  29.         while left < right and data[right]['id'] >=tmp['id']:
  30.             right -=1
  31.         data[left] = data[right]            
  32.  
  33.         while left <right and data[left]['id'] <= tmp['id']:
  34.             left+=1
  35.         data[right] = data[left]
  36.  
  37.     data[left] = tmp        # 将基准元素放到该位置
  38.     return left
  39.  
  40. stus = random_list(5)
  41. random.shuffle(stus)
  42. print(stus)
  43.  
  44. quick_sort(stus,0,len(stus)-1)
  45. print(stus)

1、算法介绍，lowB三人组，快速排序的更多相关文章

  1. 算法 排序lowB三人组 冒泡排序 选择排序 插入排序

    参考博客:基于python的七种经典排序算法   [经典排序算法][集锦]     经典排序算法及python实现 首先明确,算法的实质 是 列表排序.具体就是操作的列表,将无序列表变成有序列表! 一 ...

  2. 算法之LOWB三人组之选择排序

    选择排序 思想是在一个列表中每次循环一遍,拿到最小值,接着再从剩下的无序区中继续拿最小值,如此循环,直到结束. 时间复杂度为O(n^2) # 最简单的一个选择排序,循环一个列表,拿到最小值,添加到一个 ...

  3. 算法之LOWB三人组之冒泡排序

    排序 冒泡排序(Bubble Sort)时间复杂度为O(n^2) 列表每两个相邻的数,如果前面比后面大,则交换这两个数 一趟排序完成后,则无序区减少一个数,有序区增加一个数. def bubble_s ...

  4. 算法之LOWB三人组之插入排序

    插入排序 思想:类似于抽扑克牌,共有8张扑克牌,手里默认有一张,桌面上有7张,我们每次从桌面上抽一张和手里的牌进行比较,如果比手里的牌大,则直接放到手里的牌的后面,如果比手里的牌小,则放到手里的牌的前 ...

  5. 算法排序-lowB三人组

    冒泡排序思路: 选择排序思路: 插入排序思路: 小结: 详细代码解释看下一篇

  6. 算法排序-NB三人组

    快速排序: 堆排序: 二叉树: 两种特殊二叉树: 二叉树的存储方式: 小结: 堆排序正题: 向下调整: 堆排序过程: 堆排序-内置模块: 扩展问题topk: 归并排序: 怎么使用: NB三人组小结

  7. lowB三人组算法-冒泡排序-选择排序-插入排序

    冒泡排序 时间复杂度:O(n2)  算法稳定 第一趟,从第一个数开始,相邻两个数比较,大的数交换放后,交换到最后位置得出一个第一大数 第二趟,从第一个数开始,相邻两个数比较,大的数交换放后,交换到倒数 ...

  8. 排序算法Nb三人组-快速排序

    核心思想: 将列表中第一个元素拿出来,放到一边,左右两个循环,左面的大于拿出来的数,就把他挪到右面, 右面的小于拿出来的数就把他放在左面,这是列表被第一个元素''分''为两个列表,在对两个列表进行同样 ...

  9. 排序算法lowb三人组-插入排序

    def insert_sort(li): for i in range(1, len(li)): # i表示摸到的牌的下标 tmp = li[i] # 摸到的牌 j = i - 1 while j & ...

随机推荐

  1. [UI] Elastic Stack & scrollReveal.js

    Elastic Stack & scrollReveal.js Elastic Stack http://freebiesbug.com/code-stuff/elastistack-js-d ...

  2. django配置连接多个数据库，自定义表名称

    在项目tt下新建两个app,分别为app01.app02.配置app01使用default节点数据库:app02使用hvdb节点数据库(也可以配置app01下的model既使用default,也可以使 ...

  3. lua调用c++函数返回值作用

    2015/05/28 lua调用c++接口,返回给lua函数的是压入栈的内容,可以有多个返回值.但是c++接口本身也是有返回值的,这个返回值也非常的重要,会决定最后返回到lua函数的值的个数. (1) ...

  4. SMTP服务器设置

    Web.config中使用如下配置  <system.net>    <mailSettings>        <smtp from="info@site.c ...

  5. #001 CSS快速入门讲解

    CSS入门讲解 HTML人+CSS衣服+JS动作=>DHTML CSS: 层叠样式表 CSS2.0 和 CSS3.0 版本,目前学习CSS2, CSS3只是多了一些样式出来而已 CSS 干啥用的 ...

  6. RSA算法知识

    摘自http://www.cfca.com.cn/zhishi/wz-012.htm RSA加密算法是最常用的非对称加密算法,CFCA在证书服务中离不了它.但是有不少新来的同事对它不太了解,恰好看到一 ...

  7. Day3JavaScript（一）JavaScript初识以及bom操作

    JavaScript简介 什么是JavaScript 弱类型,动态类型,基于原型的直译性的编程语言.1995年netscape(网景)在导航者浏览器中设计完成. JavaScript的特点 1.与HT ...

  8. PhotoSwipe-一个好用的图片放大缩小插件

    通过GitHub 下载PhotoSwipe https://github.com/dimsemenov/PhotoSwipe 相关的库 <link rel="stylesheet&qu ...

  9. flex使用学习

    1.指定容器为flex布局 display:flex 行内元素也可以使用Flex布局. display: inline-flex; 注意,设为Flex布局以后,子元素的float.clear和vert ...

  10. 程序集(Assembly)和模块(Managed Module)

    前言 一直都用集成开发坏境(IDE),一直对模块和程序集的概念理解的不是很直观,因为一Build就把你的单个模块塞进程序集里面去了.当然,对你的编程也不会造成太大的影响.但有些东西你最好还是知道比较好 ...