1、排序
- 从小到大排序：sorted(list)
- 从大到小排序：sorted(list, reverse=True)
- sort() 方法，改变原有数组的顺序
- sort(reverse=True)
#!/bin/Python
alist = [1, 4, 2, 3, 7, 6]
print(sorted(alist))
print(sorted(alist, reverse=True))
alist.sort()
print(alist)
alist.sort(reverse=True)
print(alist)
2、冒泡
- 1.比较相邻的元素，如果第一个比第二个大，就交换
- 2.一轮遍历，每两个相邻的元素，重复第 1 步，最大的放队尾
- 3.不包括已经排队尾的，重复第 2 步
#!/bin/Python
# -*- coding: UTF-8 -*-
#冒泡排序
def bubble_sort(lists):
#获取数组长度
count = len(lists) - 1
#N个元素遍历N次
for index in range(count, 0, -1):
#第i个和i+1个依次对比
for sub_index in range(index):
#大的元素冒上去
if lists[sub_index] > lists[sub_index + 1]:
lists[sub_index], lists[sub_index + 1] = lists[sub_index + 1], lists[sub_index]
return lists
alist = [1, 4, 2, 3, 7, 6]
print(bubble_sort(alist))
3、快排
- 1.从列表中挑出一个元素，作为基准值 key
- 2.所有小于 key 的元素放左边，所有大于 key 的元素放右边
- 3.分别递归左侧列表，右侧列表
#!/bin/Python
# -*- coding: UTF-8 -*-
#快速排序
def quick_sort(lists, left, right):
#递归过程中，发现left和right一致时，停止递归，直接返回列表
if left >= right:
return lists
#定义游标
low = left
high = right
#取参考标志，最左边的元素
key = lists[low]
while low < high:
#从最右侧向左，依次和标志元素对比，如果右侧的元素大于等于标志元素
while low < high and lists[high] >= key:
#右侧减1
high -= 1
#如果右侧的元素小于标志元素，则low赋high值
lists[low] = lists[high]
#从最左侧向右，依次和标志元素对比，如果左侧的元素小于等于标志元素
while low < high and lists[low] <= key:
#左侧加1
low += 1
#如果左侧的元素大于标志元素，则high赋low值
lists[high] = lists[low]
#最后给high位置赋值
lists[high] = key
#处理左侧元素
quick_sort(lists, left, low - 1)
#处理右侧元素
quick_sort(lists, low + 1, right)
return lists
alist = [0, 10, 88, 19, 9, 1, 7]
print(quick_sort(alist, 0, 6))
4、堆排序
- 堆排序指利用堆的数据结构设计的一种排序算法
- 堆近似于一个完全二叉树结构
- 子节点的键值小于（或者大于）它的父节点
#!/bin/Python
# -*- coding: UTF-8 -*-
#堆排序
def heap_sort(lst):
def sift_down(start, end):
"""最大堆调整"""
root = start
print "root %d start %d end %d" % (root, start, end)
while True:
child = 2 * root + 1
#print "child index: %d" % child
#终止条件，孩子的索引值超过数组最大长度
if child > end:
break
#print "lst child value: %d" % lst[child]
#确定最大的孩子节点的索引值
if child + 1 <= end and lst[child] < lst[child + 1]:
child += 1
#print "child+1 index: %d" % child
#孩子节点最大值和根节点交换
if lst[root] < lst[child]:
lst[root], lst[child] = lst[child], lst[root]
#print "lstroot %d" %d lst[root], "lstchild %d" % lst[child]
root = child
#print "root %d" % root
else:
break
print("---------------创建最大堆---------------")
#创建最大堆
print(xrange((len(lst) - 2) // 2, -1, -1))
for start in xrange((len(lst) - 2) // 2, -1, -1):
print "---->Loop start %d" % start
sift_down(start, len(lst) - 1)
print(lst)
print("---------------排序过程---------------")
#堆排序
for end in xrange(len(lst) - 1, 0, -1):
#首尾交换
lst[0], lst[end] = lst[end], lst[0]
#剩余重新堆排序
sift_down(0, end - 1)
print(lst)
return lst
alist = [70, 60, 12, 40, 30, 8, 10]
print(heap_sort(alist))
5、二分查找
- 二分查找又称折半查找
- 必须采用顺序存储结构
- 必须按关键字大小有序排列
#!/bin/Python
# -*- coding: UTF-8 -*-
#二分查找
#原始数组
alist = [0, 1, 10, 88, 19, 9, 1]
def binary_search(arr, start, end, hkey):
if start > end:
#返回-1,表示程序出现异常
return -1
#先找到数组索引的中间值
mid = start + (end - start) / 2
#如果中间值大于查找的值，则从中间值左边的数组中查找
if arr[mid] > hkey:
return binary_search(arr, start, mid - 1, hkey)
#如果中间值小于查找的值，则从中间值右边的数组中查找
if arr[mid] < hkey:
return binary_search(arr, mid + 1, end, hkey)
#返回查找的值所在的索引值
return mid
#给数组排序
alist = sorted(alist)
#打印出排序后的数组
print(alist)
#执行程序
print binary_search(alist, 0, 6, 9)
6、素数
- 素数又称质数
- 0，1 不是素数
- 除了 1 和它本身外，不能被其他自然数整除的数
#!/bin/Python
# -*- coding: UTF-8 -*-
#素数
def is_prime(n):
#0，1 不是素数
if n <= 1:
return False
#除了 1 和它本身外，不能被其他自然数整除的数
for i in range(2, n):
if n % i == 0:
return False
return True
for i in range(0, 100):
if is_prime(i):
print i
欢迎关注微信公众号"测试开发Stack"